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 create_domain_subnet(self,
vsd_zone,
ipv4_subnet,
ipv6_subnet,
network_name,
enable_ingress_replication=False):
subnet = ipv4_subnet or ipv6_subnet
net = netaddr.IPNetwork(subnet['cidr'])
req_params = {
'name': helper.get_subnet_name(subnet),
'zone': vsd_zone['ID'],
'externalID': helper.get_subnet_external_id(subnet)
}
description = helper.get_subnet_description(subnet)
extra_params = {
'description': description,
'entityState': 'UNDER_CONSTRUCTION',
'dualStackDynamicIPAllocation': False,
'ingressReplicationEnabled': enable_ingress_replication
}
if ipv4_subnet:
extra_params.update({
'address': str(net.ip),
'netmask': str(net.netmask),
'gateway': ipv4_subnet['gateway_ip'],
'enableDHCPv4': ipv4_subnet['enable_dhcp']
})
elif ipv6_subnet:
extra_params.update({
'IPv6Address': str(net.cidr),
'IPv6Gateway': ipv6_subnet['gateway_ip'],
'IPType': constants.IPV6,
'enableDHCPv6': ipv6_subnet['enable_dhcp']
})
# attach dualstack subnet to a router
if ipv4_subnet and ipv6_subnet:
params = {
'network_name': network_name,
'network_id': subnet['network_id']
}
data = helper.get_subnet_update_data(ipv4_subnet, ipv6_subnet,
params)
extra_params.update(data)
vsd_subnet = self._create_subnet(req_params, extra_params)
nuagedhcpoptions = dhcpoptions.NuageDhcpOptions(self.restproxy)
if ipv4_subnet:
nuagedhcpoptions.create_nuage_dhcp(
ipv4_subnet,
parent_id=vsd_subnet['ID'],
network_type=constants.NETWORK_TYPE_L3)
if ipv6_subnet:
nuagedhcpoptions.create_nuage_dhcp(
ipv6_subnet,
parent_id=vsd_subnet['ID'],
network_type=constants.NETWORK_TYPE_L3)
return vsd_subnet
def update_subnet_to_dualstack(self, ipv4_subnet, ipv6_subnet, params):
mapping = params['mapping']
data = helper.get_subnet_update_data(ipv4_subnet, ipv6_subnet, params)
self.update_l2domain_for_stack_exchange(mapping, **data)
nuagedhcpoptions = dhcpoptions.NuageDhcpOptions(self.restproxy)
if mapping['subnet_id'] == ipv4_subnet['id']:
nuagedhcpoptions.create_nuage_dhcp(
ipv6_subnet,
parent_id=mapping['nuage_subnet_id'],
network_type=constants.NETWORK_TYPE_L2)
if mapping['subnet_id'] == ipv6_subnet['id']:
nuagedhcpoptions.create_nuage_dhcp(
ipv4_subnet,
parent_id=mapping['nuage_subnet_id'],
network_type=constants.NETWORK_TYPE_L2)
def update_domain_subnet_to_single_stack(self, mapping, ipv4_subnet,
ipv6_subnet):
data = helper.get_subnet_update_data(ipv4_subnet, ipv6_subnet,
params=None)
self.update_domain_subnet_for_stack_exchange(
mapping['nuage_subnet_id'], **data)
nuagedhcpoptions = dhcpoptions.NuageDhcpOptions(self.restproxy)
if ipv4_subnet:
# Delete ipv6 dhcp options
nuagedhcpoptions.clear_nuage_dhcp_for_ip_version(
constants.IPV6_VERSION, mapping['nuage_subnet_id'],
constants.NETWORK_TYPE_L3)
else:
nuagedhcpoptions.clear_nuage_dhcp_for_ip_version(
constants.IPV4_VERSION, mapping['nuage_subnet_id'],
constants.NETWORK_TYPE_L3)
def __init__(self, cms_id, **kwargs):
super(VsdClientImpl, self).__init__()
self.restproxy = restproxy.RESTProxyServer(**kwargs)
self.restproxy.generate_nuage_auth()
self.get_cms(cms_id)
cms_id_helper.CMS_ID = cms_id
self.net_part = netpartition.NuageNetPartition(self.restproxy)
self.policygroups = policygroups.NuagePolicyGroups(self.restproxy)
self.redirecttargets = policygroups.NuageRedirectTargets(
self.restproxy)
self.l2domain = l2domain.NuageL2Domain(self.restproxy,
self.policygroups)
self.domain = domain.NuageDomain(self.restproxy, self.policygroups)
self.vm = vm.NuageVM(self.restproxy, self)
self.dhcp_options = dhcpoptions.NuageDhcpOptions(self.restproxy)
self.nuagegw = gateway.NuageGateway(self.restproxy, self.policygroups)
self.fwaas = fwaas.NuageFwaas(self.restproxy)
self.trunk = trunk.NuageTrunk(self.restproxy)
def create_domain_subnet(self, vsd_zone, os_subnet, pnet_binding):
req_params = {
'name': os_subnet['id'],
'net': netaddr.IPNetwork(os_subnet['cidr']),
'zone': vsd_zone['ID'],
'gateway': os_subnet['gateway_ip'],
'externalID': get_vsd_external_id(os_subnet['id'])
}
extra_params = {
'description': os_subnet.get('name'),
'entityState': 'UNDER_CONSTRUCTION'
}
nuagel3domsub = nuagelib.NuageSubnet(create_params=req_params,
extra_params=extra_params)
vsd_subnet = self.restproxy.post(nuagel3domsub.post_resource(),
nuagel3domsub.post_data())[0]
nuagedhcpoptions = dhcpoptions.NuageDhcpOptions(self.restproxy)
nuagedhcpoptions.create_nuage_dhcp(
os_subnet,
parent_id=vsd_subnet['ID'],
network_type=constants.NETWORK_TYPE_L3)
if pnet_binding:
# Get netpart id needed in process_provider_network to check the
# gateway port enterprise permissions
req_params = {'domain_id': vsd_zone['parentID']}
nuage_l3domain = nuagelib.NuageL3Domain(create_params=req_params)
domain = self.restproxy.get(nuage_l3domain.get_resource())[0]
np_id = helper.get_l3domain_np_id(self.restproxy, domain['ID'])
pnet_params = {
'pnet_binding': pnet_binding,
'nuage_subnet_id': vsd_subnet['ID'],
'netpart_id': np_id,
'neutron_subnet_id': os_subnet['id']
}
pnet_helper.process_provider_network(self.restproxy,
self.policygroups,
pnet_params)
return vsd_subnet
def delete_subnet_from_dualstack(self,
mapping,
ipv4_subnet=None,
ipv6_subnet=None):
try:
data = helper.get_subnet_update_data(ipv4_subnet,
ipv6_subnet,
params=None)
self.update_l2domain_for_stack_exchange(mapping, **data)
# Delete dhcp options:
nuagedhcpoptions = dhcpoptions.NuageDhcpOptions(self.restproxy)
if ipv4_subnet:
# Delete ipv6 dhcp options
nuagedhcpoptions.clear_nuage_dhcp_for_ip_version(
constants.IPV6_VERSION, mapping['nuage_subnet_id'],
constants.NETWORK_TYPE_L2)
else:
nuagedhcpoptions.clear_nuage_dhcp_for_ip_version(
constants.IPV4_VERSION, mapping['nuage_subnet_id'],
constants.NETWORK_TYPE_L2)
except restproxy.RESTProxyError as e:
if e.code != constants.RES_NOT_FOUND:
raise
def __init__(self, cms_id, **kwargs):
super(VsdClientImpl, self).__init__()
self.restproxy = restproxy.RESTProxyServer(**kwargs)
response = self.restproxy.generate_nuage_auth()
if self.__renew_auth_key:
threading.Thread(target=self._auth_key_renewal,
args=[response]).start()
self.verify_cms(cms_id)
cms_id_helper.CMS_ID = cms_id
self.net_part = netpartition.NuageNetPartition(self.restproxy)
self.policygroups = policygroups.NuagePolicyGroups(self.restproxy)
self.redirecttargets = policygroups.NuageRedirectTargets(
self.restproxy)
self.l2domain = l2domain.NuageL2Domain(self.restproxy,
self.policygroups)
self.domain = domain.NuageDomain(self.restproxy, self.policygroups)
self.vm = vm.NuageVM(self.restproxy, self)
self.dhcp_options = dhcpoptions.NuageDhcpOptions(self.restproxy)
self.nuagegw = gateway.NuageGateway(self.restproxy, self.policygroups)
self.trunk = trunk.NuageTrunk(self.restproxy)
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 update_l2domain_dhcp_options(self, nuage_subnet_id, neutron_subnet):
dhcpoptions.NuageDhcpOptions(self.restproxy).update_nuage_dhcp(
neutron_subnet,
parent_id=nuage_subnet_id,
network_type=constants.NETWORK_TYPE_L2)
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
