def _create_dci_lo0_network_ipam(cls, subnet_list):
db_conn = cls.db_conn
obj_type = 'network-ipam'
vn_fq_name = DCI_VN_FQ_NAME
vn_id = db_conn.fq_name_to_uuid('virtual_network', vn_fq_name)
ok, res = cls.dbe_read(db_conn,
'virtual_network',
vn_id,
obj_fields=['network_ipam_refs'])
if not ok:
return ok, res
ipam_fq = DCI_IPAM_FQ_NAME
# find ipam object if created already
ipam_ref = cls._find_dci_ipam(ipam_fq, res.get('network_ipam_refs'))
ipam_uuid = None
if ipam_ref:
try:
ipam_uuid = db_conn.fq_name_to_uuid('network_ipam', ipam_fq)
except NoIdError as e:
return False, str(e)
api_server = cls.server
# create ipam object for the first time
if not ipam_uuid:
ipam = NetworkIpam(ipam_fq[-1])
ipam_dict = json.dumps(ipam, default=_obj_serializer_all)
try:
ok, ipam_obj = api_server.internal_request_create(
obj_type, json.loads(ipam_dict))
except HttpError as e:
return False, (e.status_code, e.content)
ipam_obj = ipam_obj.get(obj_type)
ipam_uuid = ipam_obj.get('uuid')
# build ipam subnets
ipam_list = []
if subnet_list and subnet_list.get('subnet'):
sub_list = subnet_list.get('subnet')
for sub in sub_list or []:
ipam_sub = IpamSubnetType(subnet=SubnetType(
sub.get('ip_prefix'), sub.get('ip_prefix_len')))
ipam_list.append(ipam_sub)
# update ipam
attr = VnSubnetsType(ipam_subnets=ipam_list)
attr_dict = json.loads(json.dumps(attr, default=_obj_serializer_all))
op = 'ADD'
try:
api_server.internal_request_ref_update('virtual-network',
vn_id,
op,
obj_type,
ipam_uuid,
ipam_fq,
attr=attr_dict)
except HttpError as e:
return False, (e.status_code, e.content)
return True, ''
def _read_and_create_network_ipam(cls, vn_obj, subnets, ipam_fq_name):
ipam_list = []
for subnet in subnets or []:
ipam_sub = IpamSubnetType(subnet=SubnetType(
subnet.get('ip_prefix'), subnet.get('ip_prefix_len')),
default_gateway=None,
enable_dhcp=False,
addr_from_start=False)
ipam_list.append(ipam_sub)
if len(vn_obj.get('network_ipam_refs', [])) == 0:
# create network IPAM
kwargs = {'display_name': ipam_fq_name[-1]}
kwargs['parent_type'] = 'project'
kwargs['ipam_subnet_method'] = 'flat-subnet'
kwargs['ipam_subnets'] = IpamSubnets(ipam_list)
kwargs['ipam_subnetting'] = False
ok, result = cls.server.get_resource_class('network_ipam').\
locate(ipam_fq_name, **kwargs)
if not ok:
return ok, result
else:
# Update network IPAM
ok, result = cls.server.get_resource_class('network_ipam').\
locate(ipam_fq_name, create_it=False)
if not ok:
return ok, result
ipam_obj = NetworkIpam(name=ipam_fq_name[-1],
fq_name=ipam_fq_name,
parent_type='project',
ipam_subnet_method='flat-subnet',
ipam_subnets=IpamSubnets(ipam_list),
ipam_subnetting=False)
ipam_dict = json.dumps(ipam_obj, default=_obj_serializer_all)
try:
cls.server.internal_request_update('network-ipam',
result['uuid'],
json.loads(ipam_dict))
except HttpError as e:
return False, (e.status_code, e.content)
ipam_uuid = result['uuid']
# Do this only for VN and IPAM creation.Skip for update. Currently we
# support only one IPAM
if len(vn_obj.get('network_ipam_refs', [])) == 0:
try:
op = 'ADD'
cls.server.internal_request_ref_update(
'virtual-network',
vn_obj['uuid'],
op,
'network-ipam',
ipam_uuid,
ipam_fq_name,
attr=json.loads(
json.dumps(VnSubnetsType([]),
default=_obj_serializer_all)))
except HttpError as e:
return False, (e.status_code, e.content)
return True, result
def test_lr_v4_subnets(self):
# Create Domain
domain = Domain('my-lr-domain')
self._vnc_lib.domain_create(domain)
# Create Project
project = Project('my-lr-proj', domain)
self._vnc_lib.project_create(project)
# Create NetworkIpam
ipam = NetworkIpam('default-network-ipam', project, IpamType("dhcp"))
self._vnc_lib.network_ipam_create(ipam)
ipam = self._vnc_lib.network_ipam_read(
['my-lr-domain', 'my-lr-proj', 'default-network-ipam'])
# Create subnets
ipam_sn_v4_vn1 = IpamSubnetType(subnet=SubnetType('11.1.1.0', 24))
ipam_sn_v6_vn1 = IpamSubnetType(subnet=SubnetType('fd11::', 120))
ipam_sn_v4_vn2 = IpamSubnetType(subnet=SubnetType('11.1.2.0', 24))
ipam_sn_v6_vn2 = IpamSubnetType(subnet=SubnetType('fd12::', 120))
# Create VN my-vn-1
vn1 = VirtualNetwork('my-vn-1', project)
vn1.add_network_ipam(ipam,
VnSubnetsType([ipam_sn_v4_vn1, ipam_sn_v6_vn1]))
self._vnc_lib.virtual_network_create(vn1)
net_obj1 = self._vnc_lib.virtual_network_read(id=vn1.uuid)
# Create VN my-vn-2
vn2 = VirtualNetwork('my-vn-2', project)
vn2.add_network_ipam(ipam,
VnSubnetsType([ipam_sn_v4_vn2, ipam_sn_v6_vn2]))
self._vnc_lib.virtual_network_create(vn2)
net_obj2 = self._vnc_lib.virtual_network_read(id=vn2.uuid)
# Create Logical Router
lr = LogicalRouter('router-test-v4-%s' % self.id(), project)
lr_uuid = self._vnc_lib.logical_router_create(lr)
# Create a Virtual Machine Interface belonging to my-vn-1
id_perms = IdPermsType(enable=True)
port_obj1 = VirtualMachineInterface(str(uuid.uuid4()),
parent_obj=project,
id_perms=id_perms)
port_obj1.uuid = port_obj1.name
port_obj1.set_virtual_network(vn1)
port_obj1.set_virtual_machine_interface_device_owner(
'DEVICE_OWNER_ROUTER_INTF')
# Assign gateway ip
ipam_refs = net_obj1.get_network_ipam_refs()
for ipam_ref in ipam_refs:
subnets = ipam_ref['attr'].get_ipam_subnets()
for subnet in subnets:
cidr = '%s/%s' % (subnet.subnet.get_ip_prefix(),
subnet.subnet.get_ip_prefix_len())
if IPNetwork(cidr).version == 4:
gateway_ip = subnet.get_default_gateway()
self._vnc_lib.virtual_machine_interface_create(port_obj1)
# Create v4 Ip object
ip_obj1 = InstanceIp(name=str(uuid.uuid4()),
instance_ip_address=gateway_ip,
instance_ip_family='v4')
ip_obj1.uuid = ip_obj1.name
ip_obj1.set_virtual_machine_interface(port_obj1)
ip_obj1.set_virtual_network(net_obj1)
ip_id1 = self._vnc_lib.instance_ip_create(ip_obj1)
# Add Router Interface (test being subnet)
lr.add_virtual_machine_interface(port_obj1)
self._vnc_lib.logical_router_update(lr)
# Create a Virtual Machine Interface belonging to my-vn-2
port_obj2 = VirtualMachineInterface(str(uuid.uuid4()),
parent_obj=project,
id_perms=id_perms)
port_obj2.uuid = port_obj2.name
port_obj2.set_virtual_network(vn2)
port_obj2.set_virtual_machine_interface_device_owner(
'DEVICE_OWNER_ROUTER_INTF')
# Assign gateway ip
ipam_refs = net_obj2.get_network_ipam_refs()
for ipam_ref in ipam_refs:
subnets = ipam_ref['attr'].get_ipam_subnets()
for subnet in subnets:
cidr = '%s/%s' % (subnet.subnet.get_ip_prefix(),
subnet.subnet.get_ip_prefix_len())
if IPNetwork(cidr).version == 4:
gateway_ip = subnet.get_default_gateway()
self._vnc_lib.virtual_machine_interface_create(port_obj2)
# Create v4 Ip object
ip_obj2 = InstanceIp(name=str(uuid.uuid4()),
instance_ip_address=gateway_ip,
instance_ip_family='v4')
ip_obj2.uuid = ip_obj2.name
ip_obj2.set_virtual_machine_interface(port_obj2)
ip_obj2.set_virtual_network(net_obj2)
ip_id2 = self._vnc_lib.instance_ip_create(ip_obj2)
# Add Router Interface (test being subnet)
lr.add_virtual_machine_interface(port_obj2)
self._vnc_lib.logical_router_update(lr)
# TODO: Schema transformer not integrated in the tests,
# hence route-target refs not set yet
# Verify Route Target Creation
rt_refs = lr.get_route_target_refs()
for rt_ref in rt_refs or []:
rt_obj = self._vnc_lib.route_target_read(id=rt_ref['uuid'])
ri_refs = rt_obj.get_routing_instance_back_refs()
for ri_ref in ri_refs:
ri_obj = self.vnc_lib.routing_instance_read(id=ri_ref['uuid'])
ri_name = ri_obj.get_display_name()
if ri_name != 'my-vn-1' and ri_name != 'my-vn-2':
pass
# cleanup
self._vnc_lib.instance_ip_delete(id=ip_id1)
self._vnc_lib.instance_ip_delete(id=ip_id2)
self._vnc_lib.logical_router_delete(id=lr_uuid)
self._vnc_lib.virtual_machine_interface_delete(id=port_obj1.uuid)
self._vnc_lib.virtual_machine_interface_delete(id=port_obj2.uuid)
self._vnc_lib.virtual_network_delete(id=vn1.uuid)
self._vnc_lib.virtual_network_delete(id=vn2.uuid)
self._vnc_lib.network_ipam_delete(id=ipam.uuid)
self._vnc_lib.project_delete(id=project.uuid)
self._vnc_lib.domain_delete(id=domain.uuid)
def setUp(self):
def _carve_out_subnets(subnets, cidr):
carved_subnets = []
for subnet in subnets:
slash_x_subnets = IPNetwork(subnet.get('cidr')).subnet(cidr)
for slash_x_sn in slash_x_subnets:
carved_subnets.append({'cidr': str(slash_x_sn)})
return carved_subnets
# end _carve_out_subnets
def _get_network_ipam(ipam_name, subnets, subnetting):
def _new_subnet(cidr):
split_cidr = cidr.split('/')
return SubnetType(
ip_prefix=split_cidr[0],
ip_prefix_len=split_cidr[1])
# end _new_subnet
ipam = NetworkIpam(
name=ipam_name,
ipam_subnets=IpamSubnets([
IpamSubnetType(
subnet=_new_subnet(sn.get('cidr')),
default_gateway=sn.get('gateway'),
subnet_uuid=str(uuid.uuid1())
) for sn in subnets if int(
sn.get('cidr').split('/')[-1]) < 31
]),
ipam_subnet_method='flat-subnet',
ipam_subnetting=subnetting
)
return ipam
# end _add_network_ipam
super(TestPnfPortTuple, self).setUp()
logger.debug("setUp called")
# Create Global objects
default_gsc_name = 'default-global-system-config'
gsc_obj = self.api.global_system_config_read(
GlobalSystemConfig().fq_name)
proj_obj = self.api.project_read(Project().fq_name)
# Create PNF and spine Physical Router
pnf_obj = PhysicalRouter('pnf-' + self.id(), gsc_obj)
pnf_obj.set_physical_router_role('pnf')
self.pnf_uuid = self.api.physical_router_create(pnf_obj)
# Create spine Physical Router
spine_obj = PhysicalRouter('spine-' + self.id(), gsc_obj)
self.spine_uuid = self.api.physical_router_create(spine_obj)
# Create left/right LR
left_lr_name = 'left_lr-' + self.id()
left_lr_obj = LogicalRouter(name=left_lr_name, parent_obj=proj_obj)
left_lr_obj.add_physical_router(spine_obj)
self.left_lr_uuid = self.api.logical_router_create(left_lr_obj)
right_lr_name = 'right_lr-' + self.id()
right_lr_obj = LogicalRouter(name=right_lr_name, parent_obj=proj_obj)
right_lr_obj.add_physical_router(spine_obj)
self.right_lr_uuid = self.api.logical_router_create(right_lr_obj)
# create left, right PNF PI
left_pnf_pi_obj = PhysicalInterface(
'ge-0/0/1-' + self.id(), parent_obj=pnf_obj)
right_pnf_pi_obj = PhysicalInterface(
'ge-0/0/2-' + self.id(), parent_obj=pnf_obj)
lo_pnf_pi_obj = PhysicalInterface('lo0', parent_obj=pnf_obj)
self.left_pnf_pi_uuid = self.api.physical_interface_create(
left_pnf_pi_obj)
self.right_pnf_pi_uuid = self.api.physical_interface_create(
right_pnf_pi_obj)
self.lo_pnf_pi_uuid = self.api.physical_interface_create(lo_pnf_pi_obj)
# create left, right spine PI
left_spine_pi_obj = PhysicalInterface(
'xe-0/0/1-' + self.id(), parent_obj=spine_obj)
right_spine_pi_obj = PhysicalInterface(
'xe-0/0/2-' + self.id(), parent_obj=spine_obj)
self.left_spine_pi_uuid = self.api.physical_interface_create(
left_spine_pi_obj)
self.right_spine_pi_uuid = self.api.physical_interface_create(
right_spine_pi_obj)
# Create Service Appliance Set
sas_obj = ServiceApplianceSet('sas-' + self.id(), gsc_obj)
sas_obj.set_service_appliance_set_virtualization_type(
'physical-device')
self.sas_uuid = self.api.service_appliance_set_create(sas_obj)
# Create Service template
st_obj = ServiceTemplate(name='st-' + self.id())
st_obj.set_service_appliance_set(sas_obj)
svc_properties = ServiceTemplateType()
svc_properties.set_service_virtualization_type('physical-device')
if_type = ServiceTemplateInterfaceType()
if_type.set_service_interface_type('left')
svc_properties.add_interface_type(if_type)
if_type = ServiceTemplateInterfaceType()
if_type.set_service_interface_type('right')
svc_properties.add_interface_type(if_type)
st_obj.set_service_template_properties(svc_properties)
self.st_uuid = self.api.service_template_create(st_obj)
# Create Service Instance object
si_fqn = ['default-domain', 'default-project', 'si-' + self.id()]
si_obj = ServiceInstance(fq_name=si_fqn)
si_obj.fq_name = si_fqn
si_obj.add_service_template(st_obj)
kvp_array = []
kvp = KeyValuePair("left-svc-vlan", "100")
kvp_array.append(kvp)
kvp = KeyValuePair("right-svc-vlan", "101")
kvp_array.append(kvp)
kvp = KeyValuePair("left-svc-asns", "66000,66001")
kvp_array.append(kvp)
kvp = KeyValuePair("right-svc-asns", "66000,66002")
kvp_array.append(kvp)
kvps = KeyValuePairs()
kvps.set_key_value_pair(kvp_array)
si_obj.set_annotations(kvps)
props = ServiceInstanceType()
props.set_service_virtualization_type('physical-device')
props.set_ha_mode("active-standby")
si_obj.set_service_instance_properties(props)
self.si_uuid = self.api.service_instance_create(si_obj)
# Create service appliance
sa_obj = ServiceAppliance('sa-' + self.id(), parent_obj=sas_obj)
kvp_array = []
kvp = KeyValuePair(
"left-attachment-point",
default_gsc_name +
':' +
'spine-' +
self.id() +
':' +
'xe-0/0/1-' +
self.id())
kvp_array.append(kvp)
kvp = KeyValuePair(
"right-attachment-point",
default_gsc_name +
':' +
'spine-' +
self.id() +
':' +
'xe-0/0/2-' +
self.id())
kvp_array.append(kvp)
kvps = KeyValuePairs()
kvps.set_key_value_pair(kvp_array)
sa_obj.set_service_appliance_properties(kvps)
sa_obj.set_service_appliance_virtualization_type('physical-device')
attr = ServiceApplianceInterfaceType(interface_type='left')
sa_obj.add_physical_interface(left_pnf_pi_obj, attr)
attr = ServiceApplianceInterfaceType(interface_type='right')
sa_obj.add_physical_interface(right_pnf_pi_obj, attr)
self.sa_uuid = self.api.service_appliance_create(sa_obj)
# Create fabric and add it to spine and PNF
fab_obj = Fabric('fab-' + self.id())
self.fab_uuid = self.api.fabric_create(fab_obj)
pnf_obj.add_fabric(fab_obj)
self.api.physical_router_update(pnf_obj)
spine_obj.add_fabric(fab_obj)
self.api.physical_router_update(spine_obj)
fab_obj = self.api.fabric_read(id=self.fab_uuid)
# Create PNF service chain IPAM/network
pnf_cidr = [{'cidr': "10.1.1.0/28"}]
peer_subnets = _carve_out_subnets(pnf_cidr, 29)
pnf_vn_obj = VirtualNetwork(
name='fab-' + self.id() + '-pnf-servicechain-network',
virtual_network_properties=VirtualNetworkType(
forwarding_mode='l3'),
address_allocation_mode='flat-subnet-only')
self.pnf_vn_uuid = self.api.virtual_network_create(pnf_vn_obj)
pnf_ipam_obj = _get_network_ipam(
'fab-' +
self.id() +
'-pnf-servicechain-network-ipam',
peer_subnets,
True)
self.pnf_ipam_uuid = self.api.network_ipam_create(pnf_ipam_obj)
pnf_vn_obj.add_network_ipam(pnf_ipam_obj, VnSubnetsType([]))
self.api.virtual_network_update(pnf_vn_obj)
fab_obj = self.api.fabric_read(id=self.fab_uuid)
fab_obj.add_virtual_network(
pnf_vn_obj, FabricNetworkTag(
network_type='pnf-servicechain'))
self.api.fabric_update(fab_obj)
# Create loopback IPAM/network
lo_cidr = [{'cidr': "100.100.100.0/28"}]
peer_subnets = _carve_out_subnets(lo_cidr, 28)
lo_vn_obj = VirtualNetwork(
name='fab-' + self.id() + '-loopback-network',
virtual_network_properties=VirtualNetworkType(
forwarding_mode='l3'),
address_allocation_mode='flat-subnet-only')
self.lo_vn_uuid = self.api.virtual_network_create(lo_vn_obj)
lo_ipam_obj = _get_network_ipam(
'fab-' +
self.id() +
'-loopback-network-ipam',
peer_subnets,
False)
self.lo_ipam_uuid = self.api.network_ipam_create(lo_ipam_obj)
lo_vn_obj.add_network_ipam(lo_ipam_obj, VnSubnetsType([]))
self.api.virtual_network_update(lo_vn_obj)
fab_obj = self.api.fabric_read(id=self.fab_uuid)
fab_obj.add_virtual_network(
lo_vn_obj, FabricNetworkTag(
network_type='loopback'))
self.api.fabric_update(fab_obj)
def _create_isolated_ns_virtual_network(self,
ns_name,
vn_name,
vn_type,
proj_obj,
ipam_obj=None,
provider=None,
enforce_policy=False):
"""
Create/Update a virtual network for this namespace.
"""
vn_exists = False
vn = VirtualNetwork(name=vn_name,
parent_obj=proj_obj,
virtual_network_properties=VirtualNetworkType(
forwarding_mode='l3'),
address_allocation_mode='flat-subnet-only')
try:
vn_obj = self._vnc_lib.virtual_network_read(
fq_name=vn.get_fq_name())
vn_exists = True
except NoIdError:
# VN does not exist. Create one.
vn_obj = vn
fabric_snat = False
if vn_type == 'pod-network':
if self._is_ip_fabric_snat_enabled(ns_name):
fabric_snat = True
if not vn_exists:
# Add annotatins on this isolated virtual-network.
VirtualNetworkKM.add_annotations(self,
vn,
namespace=ns_name,
name=ns_name,
isolated='True')
# Instance-Ip for pods on this VN, should be allocated from
# cluster pod ipam. Attach the cluster pod-ipam object
# to this virtual network.
vn_obj.add_network_ipam(ipam_obj, VnSubnetsType([]))
if provider:
# enable ip_fabric_forwarding
vn_obj.add_virtual_network(provider)
elif fabric_snat:
# enable fabric_snat
vn_obj.set_fabric_snat(True)
else:
# disable fabric_snat
vn_obj.set_fabric_snat(False)
vn_uuid = self._vnc_lib.virtual_network_create(vn_obj)
# Cache the virtual network.
VirtualNetworkKM.locate(vn_uuid)
else:
ip_fabric_enabled = False
if provider:
vn_refs = vn_obj.get_virtual_network_refs()
ip_fabric_fq_name = provider.fq_name
for vn in vn_refs or []:
vn_fq_name = vn['to']
if vn_fq_name == ip_fabric_fq_name:
ip_fabric_enabled = True
break
if not ip_fabric_enabled and fabric_snat:
# enable fabric_snat
vn_obj.set_fabric_snat(True)
else:
# disable fabric_snat
vn_obj.set_fabric_snat(False)
# Update VN.
self._vnc_lib.virtual_network_update(vn_obj)
vn_uuid = vn_obj.get_uuid()
vn_obj = self._vnc_lib.virtual_network_read(id=vn_uuid)
# If required, enforce security policy at virtual network level.
if enforce_policy:
self._vnc_lib.set_tags(
vn_obj,
self._labels.get_labels_dict(
VncSecurityPolicy.cluster_aps_uuid))
return vn_obj