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_l2domain_np_id(restproxy_serv, l2dom_id):
req_params = {
'domain_id': l2dom_id
}
nuage_l2_domain = nuagelib.NuageL2Domain(create_params=req_params)
return restproxy_serv.get(nuage_l2_domain.get_resource(l2dom_id),
required=True)[0]['parentID']
def delete_resources_created_for_l2dom_providernet(restproxy_serv, l2domid):
nuagel2domain = nuagelib.NuageL2Domain()
# Get bridge vport on given l2domain
bridge_vports = restproxy_serv.rest_call(
'GET', nuagel2domain.get_all_vports(l2domid), '',
nuagel2domain.extra_headers_vport_get())
if not nuagel2domain.validate(bridge_vports):
raise restproxy.RESTProxyError(nuagel2domain.error_msg)
# Delete bridge interface and bridge vport if it is subnet created for
# provider net
if bridge_vports and bridge_vports[VSD_RESP_OBJ]:
nuage_vport = nuagelib.NuageVPort()
bridge_vport = bridge_vports[VSD_RESP_OBJ][0]
bridge_iface = restproxy_serv.rest_call(
'GET', nuage_vport.post_bridge_interface(bridge_vport['ID']),
'')
if not nuage_vport.validate(bridge_iface):
raise restproxy.RESTProxyError(nuage_vport.error_msg)
if bridge_iface and bridge_iface[VSD_RESP_OBJ]:
bridge_iface_id = bridge_iface[VSD_RESP_OBJ][0]['ID']
restproxy_serv.rest_call(
'DELETE',
nuage_vport.del_bridge_interface(bridge_iface_id),
'')
# Delete bridge vport
nuage_vport = nuagelib.NuageVPort({'vport_id': bridge_vport['ID']})
restproxy_serv.delete(nuage_vport.delete_resource())
# Delete vlan obj on gateway port
delete_vlan_for_gw_port(restproxy_serv, bridge_vport)
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 check_if_l2Dom_in_correct_ent(self, nuage_l2dom_id, nuage_netpart):
nuagesubn = nuagelib.NuageSubnet()
resp_subn = self.restproxy.rest_call(
'GET', nuagesubn.get_resource(nuage_l2dom_id), '')
if not nuagesubn.validate(resp_subn):
nuagel2dom = nuagelib.NuageL2Domain()
response = self.restproxy.rest_call(
'GET', nuagel2dom.get_resource(nuage_l2dom_id), '')
if not nuagel2dom.validate(response):
raise restproxy.RESTProxyError(nuagel2dom.error_msg)
else:
if response[3][0]['parentID'] == nuage_netpart['id']:
return True
return False
else:
req_params = {'zone_id': resp_subn[3][0]['parentID']}
nuagezone = nuagelib.NuageZone(create_params=req_params)
resp_zone = self.restproxy.rest_call('GET',
nuagezone.get_resource(), '')
if not nuagezone.validate(resp_zone):
raise restproxy.RESTProxyError(nuagezone.error_msg)
req_params = {'domain_id': resp_zone[3][0]['parentID']}
nuage_l3domain = nuagelib.NuageL3Domain(create_params=req_params)
dom_resp = self.restproxy.rest_call('GET',
nuage_l3domain.get_resource(),
'')
if not nuage_l3domain.validate(dom_resp):
raise restproxy.RESTProxyError(nuage_l3domain.error_msg)
if dom_resp[3][0]['parentID'] == nuage_netpart['id']:
return True
return False
def update_l2domain(self, nuage_l2dom_id, **kwargs):
# Generate payload for the update
data = self._gen_payload_l2domain_and_template(**kwargs)
if data:
nuage_l2domain = nuagelib.NuageL2Domain()
self.restproxy.put(nuage_l2domain.put_resource(nuage_l2dom_id),
data)
def update_subnet(self, neutron_subnet, params):
type = constants.NETWORK_TYPE_L3
new_name = neutron_subnet.get('name')
if params['type']:
type = constants.NETWORK_TYPE_L2
nuagedhcpoptions = dhcpoptions.NuageDhcpOptions(self.restproxy)
nuagedhcpoptions.update_nuage_dhcp(neutron_subnet,
parent_id=params['parent_id'],
network_type=type)
if type == constants.NETWORK_TYPE_L2 and 'dhcp_ip' in params:
nuagel2domtemplate = nuagelib.NuageL2DomTemplate()
if neutron_subnet.get('enable_dhcp'):
# Enable dhcpmanaged on the l2domain template
net = params['net']
data = {
"DHCPManaged": neutron_subnet['enable_dhcp'],
"address": str(net.ip),
"netmask": str(net.netmask),
"gateway": params['dhcp_ip'],
}
response = self.restproxy.rest_call(
'PUT', nuagel2domtemplate.put_resource(params['type']),
data)
else:
# Disable dhcpmanaged on the l2domain template
response = self.restproxy.rest_call(
'PUT', nuagel2domtemplate.put_resource(params['type']),
{'DHCPManaged': False})
if not nuagel2domtemplate.validate(response):
raise restproxy.RESTProxyError(nuagel2domtemplate.error_msg)
if new_name:
# update the description on the VSD for this subnet if required
# If a subnet is updated from horizon, we get the name of the
# subnet aswell in the subnet dict for update.
if type == constants.NETWORK_TYPE_L2:
nuagel2domain = nuagelib.NuageL2Domain()
l2dom = self.restproxy.rest_call(
'GET', nuagel2domain.get_resource(params['parent_id']), '')
if not nuagel2domain.validate(l2dom):
raise restproxy.RESTProxyError(nuagel2domain.error_msg)
if nuagel2domain.get_description(l2dom) != new_name:
response = self.restproxy.rest_call(
'PUT', nuagel2domain.put_resource(params['parent_id']),
{'description': neutron_subnet['name']})
if not nuagel2domain.validate(response):
raise restproxy.RESTProxyError(nuagel2domain.error_msg)
else:
nuagesubn = nuagelib.NuageSubnet()
l3dom = self.restproxy.rest_call(
'GET', nuagesubn.get_resource(params['parent_id']), '')
if not nuagesubn.validate(l3dom):
raise restproxy.RESTProxyError(nuagesubn.error_msg)
if nuagesubn.get_description(l3dom) != new_name:
response = self.restproxy.rest_call(
'PUT', nuagesubn.put_resource(params['parent_id']),
{'description': neutron_subnet['name']})
if not nuagesubn.validate(response):
raise restproxy.RESTProxyError(nuagesubn.error_msg)
def vms_on_l2domain(self, l2dom_id):
nuagel2dom = nuagelib.NuageL2Domain()
response = self.restproxy.rest_call(
'GET',
nuagel2dom.vm_get_resource(l2dom_id),
'')
return nuagel2dom.vm_exists(response)
def get_nuage_subnet(restproxy_serv, subnet_mapping):
if subnet_mapping is None:
return None
nuage_subnet_id = subnet_mapping["nuage_subnet_id"]
if subnet_mapping['nuage_l2dom_tmplt_id']:
resource_class = nuagelib.NuageL2Domain()
else:
resource_class = nuagelib.NuageSubnet()
subnets = restproxy_serv.get(resource_class.get_resource(nuage_subnet_id))
return subnets[0] if subnets else None
def update_l2domain_for_stack_exchange(self, mapping, **data):
nuagel2domtmplt = nuagelib.NuageL2DomTemplate()
self.restproxy.put(
nuagel2domtmplt.put_resource(mapping['nuage_l2dom_tmplt_id']),
data)
# update the description for l2domain
nuagel2dom = nuagelib.NuageL2Domain()
if data.get('description'):
l2dom_data = {'description': data['description']}
self.restproxy.put(
nuagel2dom.put_resource(mapping['nuage_subnet_id']),
l2dom_data)
def get_l2domain_np_id(restproxy_serv, l2dom_id):
req_params = {'domain_id': l2dom_id}
nuage_l2_domain = nuagelib.NuageL2Domain(create_params=req_params)
response = restproxy_serv.rest_call('GET',
nuage_l2_domain.get_resource(l2dom_id),
'')
if not nuage_l2_domain.validate(response):
raise restproxy.RESTProxyError(nuage_l2_domain.error_msg)
if response[3]:
return response[3][0]['parentID']
def nuage_vports_on_l2domain(self, l2dom_id, pnet_binding):
nuagel2dom = nuagelib.NuageL2Domain()
if pnet_binding:
response = self.restproxy.rest_call(
'GET',
nuagel2dom.get_all_vports(l2dom_id),
'',
extra_headers=(
nuagel2dom.extra_headers_host_and_vm_vport_get()))
else:
response = self.restproxy.rest_call(
'GET', nuagel2dom.get_all_vports(l2dom_id), '')
return nuagel2dom.get_validate(response)
def get_nuage_cidr(self, nuage_subnetid):
nuagesubn = nuagelib.NuageSubnet()
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)
return nuagel2dom.get_cidr_info(response)
else:
return nuagesubn.get_cidr_info(response)
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_subnet(restproxy_serv, subnet_mapping):
if subnet_mapping is None:
return None
params = {'externalID': get_vsd_external_id(subnet_mapping["subnet_id"])}
nuage_subnet_id = subnet_mapping["nuage_subnet_id"]
if subnet_mapping['nuage_l2dom_tmplt_id']:
resource_class = nuagelib.NuageL2Domain(create_params=params)
else:
resource_class = nuagelib.NuageSubnet(create_params=params)
try:
response = restproxy_serv.get(
resource_class.get_resource(nuage_subnet_id))
return response[0]
except restproxy.RESTProxyError:
return None
def get_gateway_ip_for_advsub(self, vsd_subnet):
LOG.debug("vsdclient.get_gateway_ip_for_advsub() called")
if vsd_subnet['type'] == constants.SUBNET:
return vsd_subnet['gateway']
else:
nuagel2dom = nuagelib.NuageL2Domain()
dhcpoptions = self.restproxy.get(
nuagel2dom.dhcp_get_resource(vsd_subnet['ID']))
# dhcp_port_exist will exist in case for adv. subnet when it is
# set via rest call on VSD
gw_ip = None
for dhcpoption in dhcpoptions:
if dhcpoption['type'] == constants.DHCP_ROUTER_OPTION:
gw_ip = nuagel2dom.get_gwIp_set_via_dhcp(dhcpoption)
return gw_ip
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 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 detach_nuage_group_to_nuagenet(self, tenants, nuage_subnetid, shared):
nuagesubn = nuagelib.NuageSubnet()
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):
# This is the case where the VSD-Managed subnet is deleted
# from VSD first and then neutron subnet-delete operation
# is performed from openstack
# for both l2/l3 case we'll return form here
return
params = {'l2dom_id': nuage_subnetid}
nuagepermission = nuagelib.NuagePermission(create_params=params)
resource = nuagepermission.get_resource_by_l2dom_id()
else:
zone_id = nuagesubn.get_parentzone(response)
params = {'zone_id': zone_id}
nuagepermission = nuagelib.NuagePermission(create_params=params)
resource = nuagepermission.get_resource_by_zone_id()
nuage_dom = helper.get_nuage_domain_by_zoneid(
self.restproxy, zone_id)
if nuage_dom['externalID']:
# The perm. attached to the zone when the router is deleted
# from openstack
return
response = self.restproxy.rest_call('GET', resource, '')
if not nuagepermission.validate(response):
if response[0] == constants.RES_NOT_FOUND:
return
raise restproxy.RESTProxyError(nuagepermission.error_msg,
nuagepermission.vsd_error_code)
permissions = response[3]
if shared:
tenants.append("Everybody")
for permission in permissions:
if permission['permittedEntityName'] in tenants:
self.restproxy.delete(
nuagepermission.delete_resource(permission['ID']))
def get_l2domain_fields_for_pg(restproxy_serv, l2dom_id, fields):
"""This method will fetch an l2domain even if it is MARKED_FOR_DELETION.
Policygroup code actulally needs this because it is the only way to find
the netpartition for a given policygroup when the policygroup is part of
such a marked l2domain.
"""
nuage_l2_domain = nuagelib.NuageL2Domain()
response = restproxy_serv._get_ignore_marked_for_deletion(
nuage_l2_domain.get_resource(l2dom_id))
l2dom = {}
if response:
for field in fields:
l2dom[field] = response[0][field]
return l2dom
def detach_nuage_group_to_nuagenet(self, tenants, nuage_subnetid, shared):
nuagesubn = nuagelib.NuageSubnet()
try:
subnet = self.restproxy.get(nuagesubn.get_resource(nuage_subnetid),
required=True)[0]
except restproxy.ResourceNotFoundException:
nuagel2dom = nuagelib.NuageL2Domain()
try:
self.restproxy.get(nuagel2dom.get_resource(nuage_subnetid),
required=True)
except restproxy.ResourceNotFoundException:
# This is the case where the VSD-Managed subnet is deleted
# from VSD first and then neutron subnet-delete operation
# is performed from openstack
# for both l2/l3 case we'll return form here
return
params = {'l2dom_id': nuage_subnetid}
nuagepermission = nuagelib.NuagePermission(create_params=params)
resource = nuagepermission.get_resource_by_l2dom_id()
else:
zone_id = subnet['parentID']
params = {'zone_id': zone_id}
nuagepermission = nuagelib.NuagePermission(create_params=params)
resource = nuagepermission.get_resource_by_zone_id()
nuage_dom = helper.get_nuage_domain_by_zoneid(
self.restproxy, zone_id)
if nuage_dom['externalID']:
# The perm. attached to the zone when the router is deleted
# from openstack
return
try:
permissions = self.restproxy.get(resource, required=True)
except restproxy.ResourceNotFoundException as e:
if e.code == constants.RES_NOT_FOUND:
return
raise nuagepermission.get_rest_proxy_error()
if shared:
tenants.append("Everybody")
for permission in permissions:
if permission['permittedEntityName'] in tenants:
self.restproxy.delete(
nuagepermission.delete_resource(permission['ID']))
def check_if_l2_dom_in_correct_ent(self, nuage_l2dom_id, nuage_netpart):
nuagesubn = nuagelib.NuageSubnet()
try:
subnet = self.restproxy.get(nuagesubn.get_resource(nuage_l2dom_id),
required=True)[0]
except restproxy.ResourceNotFoundException:
nuagel2dom = nuagelib.NuageL2Domain()
l2_dom = self.restproxy.get(
nuagel2dom.get_resource(nuage_l2dom_id), required=True)[0]
return l2_dom['parentID'] == nuage_netpart['id']
else:
req_params = {'zone_id': subnet['parentID']}
nuagezone = nuagelib.NuageZone(create_params=req_params)
zone = self.restproxy.get(nuagezone.get_resource(),
required=True)[0]
req_params = {'domain_id': zone['parentID']}
nuage_l3domain = nuagelib.NuageL3Domain(create_params=req_params)
l3_dom = self.restproxy.get(nuage_l3domain.get_resource(),
required=True)[0]
return l3_dom['parentID'] == nuage_netpart['id']
def get_subnet_by_externalID(restproxy_serv, subnet_id):
req_params = {'externalID': get_vsd_external_id(subnet_id)}
nuage_subnet = None
nuage_l2_domain = nuagelib.NuageL2Domain(create_params=req_params)
response = restproxy_serv.rest_call('GET',
nuage_l2_domain.get_all_resources(),
'',
nuage_l2_domain.extra_headers_get())
if nuage_l2_domain.get_validate(response):
nuage_subnet = nuage_l2_domain.get_response_obj(response)
nuage_subnet['type'] = constants.L2DOMAIN
else:
nuage_domainsubn = nuagelib.NuageSubnet(create_params=req_params)
response = restproxy_serv.rest_call(
'GET', nuage_domainsubn.get_all_resources(), '',
nuage_l2_domain.extra_headers_get())
if nuage_domainsubn.get_validate(response):
nuage_subnet = nuage_domainsubn.get_response_obj(response)
nuage_subnet['type'] = constants.SUBNET
return nuage_subnet
def delete_subnet(self, id):
params = {'externalID': get_vsd_external_id(id)}
nuagel2domain = nuagelib.NuageL2Domain(create_params=params)
response = self.restproxy.rest_call(
'GET',
nuagel2domain.get_resource_with_ext_id(),
'',
extra_headers=nuagel2domain.extra_headers_get())
if nuagel2domain.get_validate(response):
nuagel2domtemplates = nuagelib.NuageL2DomTemplate()
template_id = nuagel2domain.get_template_id(response)
resp_temp = self.restproxy.rest_call(
'GET', nuagel2domtemplates.get_resource(template_id), '')
if not nuagel2domtemplates.validate(resp_temp):
raise restproxy.RESTProxyError(nuagel2domtemplates.error_msg)
l2domain_id = nuagel2domain.get_domainid(response)
try:
# Delete bridge_interface and bridge vport if it is subnet
# created for providernet
pnet_helper.delete_resources_created_for_l2dom_providernet(
self.restproxy, l2domain_id)
# delete subnet
l2dom_delete_response = self.restproxy.rest_call(
'DELETE', nuagel2domain.delete_resource(l2domain_id), '')
if not nuagel2domain.delete_validate(l2dom_delete_response):
code = nuagel2domain.get_error_code(l2dom_delete_response)
raise restproxy.RESTProxyError(nuagel2domain.error_msg,
error_code=code)
except Exception:
raise
if response[3][0]['name'] == resp_temp[3][0]['name']:
try:
self.restproxy.rest_call(
'DELETE',
nuagel2domtemplates.delete_resource(template_id), '')
except Exception:
raise
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 delete_subnet(self, l2dom_id, mapping):
nuagel2domain = nuagelib.NuageL2Domain()
l2dom = self.restproxy.get(nuagel2domain.get_resource(l2dom_id))[0]
nuagel2domtemplate = nuagelib.NuageL2DomTemplate()
if l2dom:
template_id = l2dom['templateID']
template = self.restproxy.get(
nuagel2domtemplate.get_resource(template_id))[0]
l2domain_id = l2dom['ID']
# delete subnet
self.restproxy.delete(nuagel2domain.delete_resource(l2domain_id))
if template and l2dom['name'] == template['name']:
self.restproxy.delete(
nuagel2domtemplate.delete_resource(template_id))
elif mapping and mapping['nuage_l2dom_tmplt_id']:
# Delete hanging l2dom_template
self.restproxy.delete(
nuagel2domtemplate.delete_resource(
mapping['nuage_l2dom_tmplt_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_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 get_subnet_by_id(self, nuage_id):
nuagel2dom = nuagelib.NuageL2Domain()
return self.restproxy.get(nuagel2dom.get_resource(nuage_id),
required=True)[0]
def get_gw_from_dhcp_options(self, nuage_id):
l2domain = nuagelib.NuageL2Domain()
dhcpoptions = self.restproxy.get(l2domain.dhcp_get_resource(nuage_id))
for dhcpoption in dhcpoptions:
if dhcpoption['type'] == constants.DHCP_ROUTER_OPTION:
return l2domain.get_gwIp_set_via_dhcp(dhcpoption)
