def test_vxlan_update_for_lr(self):
project = self._vnc_lib.project_read(
fq_name=['default-domain', 'default-project'])
project.set_vxlan_routing(True)
self._vnc_lib.project_update(project)
mock_zk = self._api_server._db_conn._zk_db
# Create Logical Router
lr = LogicalRouter('router-test-v4-%s' % self.id(), project)
lr.set_vxlan_network_identifier('5001')
lr.set_logical_router_type('vxlan-routing')
lr_uuid = self._vnc_lib.logical_router_create(lr)
lr_read = self._vnc_lib.logical_router_read(id=lr_uuid)
vxlan_id = lr_read.get_vxlan_network_identifier()
self.assertEqual(vxlan_id, '5001')
lr.set_vxlan_network_identifier('5002')
self._vnc_lib.logical_router_update(lr)
lr_read = self._vnc_lib.logical_router_read(id=lr_uuid)
vxlan_id = lr_read.get_vxlan_network_identifier()
self.assertEqual(vxlan_id, '5002')
int_vn_name = get_lr_internal_vn_name(lr_uuid)
int_vn_fqname = ['default-domain', 'default-project', int_vn_name]
self.assertEqual(':'.join(int_vn_fqname) + "_vxlan",
mock_zk.get_vn_from_id(int(vxlan_id)))
self._vnc_lib.logical_router_delete(id=lr_uuid)
def test_vm_port_not_added_to_lr(self):
project = self._vnc_lib.project_read(
['default-domain', 'default-project'])
ipam = self._vnc_lib.network_ipam_read(
['default-domain', 'default-project', 'default-network-ipam'])
# Create subnets
ipam_sn_v4_vn = IpamSubnetType(subnet=SubnetType('11.1.1.0', 24))
# Create VN my-vn
vn = VirtualNetwork('%s-vn' % self.id(), project)
vn.add_network_ipam(ipam, VnSubnetsType([ipam_sn_v4_vn]))
self._vnc_lib.virtual_network_create(vn)
net_obj = self._vnc_lib.virtual_network_read(id=vn.uuid)
# Create v4 Ip object
ip_obj = InstanceIp(name=str(uuid.uuid4()), instance_ip_family='v4')
ip_obj.uuid = ip_obj.name
# Create VM
vm_inst_obj = VirtualMachine(str(uuid.uuid4()))
vm_inst_obj.uuid = vm_inst_obj.name
self._vnc_lib.virtual_machine_create(vm_inst_obj)
id_perms = IdPermsType(enable=True)
vm_port_obj = VirtualMachineInterface(str(uuid.uuid4()),
vm_inst_obj,
id_perms=id_perms)
vm_port_obj.uuid = vm_port_obj.name
vm_port_obj.set_virtual_network(vn)
ip_obj.set_virtual_machine_interface(vm_port_obj)
ip_obj.set_virtual_network(net_obj)
self._vnc_lib.virtual_machine_interface_create(vm_port_obj)
self._vnc_lib.instance_ip_create(ip_obj)
# Create Logical Router
lr = LogicalRouter('router-test-v4-%s' % self.id(), project)
self._vnc_lib.logical_router_create(lr)
# Add Router Interface
lr.add_virtual_machine_interface(vm_port_obj)
with ExpectedException(RefsExistError):
self._vnc_lib.logical_router_update(lr)
lr.del_virtual_machine_interface(vm_port_obj)
# Create Port
port_obj = self.create_port(project, net_obj)
lr.add_virtual_machine_interface(port_obj)
self._vnc_lib.logical_router_update(lr)
with ExpectedException(BadRequest):
port_obj.add_virtual_machine(vm_inst_obj)
self._vnc_lib.virtual_machine_interface_update(port_obj)
self._vnc_lib.logical_router_delete(id=lr.uuid)
def test_delete_lr_missing_vn_refs(self):
# Get Project Ref
project = self._vnc_lib.project_read(
fq_name=['default-domain', 'default-project'])
lr = LogicalRouter('router-test-missing_vn_refs-%s' % (self.id()),
project)
lr.set_logical_router_type('vxlan-routing')
lr_uuid = self._vnc_lib.logical_router_create(lr)
lr = self._vnc_lib.logical_router_read(id=lr_uuid)
logger.debug('Created Logical Router ')
# Create a VN Object
vn = VirtualNetwork('%s-vn' % self.id(), project)
self._vnc_lib.virtual_network_create(vn)
# Create a Virtual Machine Interface that does not have VN Ref
id_perms = IdPermsType(enable=True)
vmi_no_vn_ref = VirtualMachineInterface(str(uuid.uuid4()),
parent_obj=project,
id_perms=id_perms)
vmi_no_vn_ref.set_virtual_network(vn)
vmi_uuid = self._vnc_lib.virtual_machine_interface_create(
vmi_no_vn_ref)
# Do not associate VN Ref to VMI and create
lr.add_virtual_machine_interface(vmi_no_vn_ref)
self._vnc_lib.logical_router_update(lr)
vmi_obj = self._vnc_lib.virtual_machine_interface_read(id=vmi_uuid)
vn_refs = vmi_obj.get_virtual_network_refs()
vn_uuid = vn_refs[0]['uuid']
self._vnc_lib.ref_update('virtual_machine_interface', vmi_uuid,
'virtual_network', vn_uuid, None, 'DELETE')
vmi_obj = self._vnc_lib.virtual_machine_interface_read(id=vmi_uuid)
vn_refs = vmi_obj.get_virtual_network_refs()
self.assertIsNone(vn_refs)
# Create a VN Object
vn2 = VirtualNetwork('%s-vn2' % self.id(), project)
self._vnc_lib.virtual_network_create(vn2)
# Create a Virtual Machine Interface that does not have VN Ref
vmi_no_vn_ref_2 = VirtualMachineInterface(str(uuid.uuid4()),
parent_obj=project,
id_perms=id_perms)
vmi_no_vn_ref_2.set_virtual_network(vn2)
self._vnc_lib.virtual_machine_interface_create(vmi_no_vn_ref_2)
# Do not associate VN Ref to VMI and create
lr.add_virtual_machine_interface(vmi_no_vn_ref_2)
self._vnc_lib.logical_router_update(lr)
# Deleting directly from api-server as api server
# will not allow deletion
self._vnc_lib.logical_router_delete(id=lr.uuid)
def test_create_logical_router(self):
lr_name = 'lr-' + self.id()
lr_fq_name = ['default-domain', 'default-project', lr_name]
lr = LogicalRouter(fq_name=lr_fq_name,
parent_type='project',
logical_router_type='vxlan-routing',
vxlan_network_identifier='5000')
lr.set_physical_router(self.pr1)
self._vnc_lib.logical_router_create(lr)
self.check_trans_info('Logical Router',
'Create',
lr_name,
pr_name=self.pr1.name)
lr.add_virtual_machine_interface(self.vmi)
self._vnc_lib.logical_router_update(lr)
self.check_trans_info('Logical Router',
'Update',
lr_name,
pr_name=self.pr1.name)
self._vnc_lib.logical_router_delete(id=lr.uuid)
self.check_trans_info('Logical Router',
'Delete',
lr_name,
pr_name=self.pr1.name)
def test_vxlan_routing_for_internal_vn(self):
project = self._vnc_lib.project_read(
fq_name=['default-domain', 'default-project'])
project.set_vxlan_routing(True)
self._vnc_lib.project_update(project)
# Create Logical Router
lr = LogicalRouter('router-test-v4-%s' % self.id(), project)
lr.set_logical_router_type('vxlan-routing')
lr_uuid = self._vnc_lib.logical_router_create(lr)
lr = self._vnc_lib.logical_router_read(id=lr_uuid)
# Check to see whether internal VN for VxLAN Routing is created.
int_vn_name = get_lr_internal_vn_name(lr_uuid)
int_vn_fqname = ['default-domain', 'default-project', int_vn_name]
try:
self._vnc_lib.virtual_network_read(fq_name=int_vn_fqname)
except NoIdError as e:
# Invisible objects do not come up in read
# calls but throws up a exception saying the
# object is invisible but cannot be read, confirming
# the presence of the object. Hack!
if "This object is not visible" not in str(e):
assert (False)
# Check to see if deleting the VN deletes the internal VN
# that was created.
self._vnc_lib.logical_router_delete(id=lr_uuid)
try:
self._vnc_lib.virtual_network_read(fq_name=int_vn_fqname)
self.fail("Logical router internal virtual network was not "
"removed")
except NoIdError:
pass
# Check to see if we are able to disable VxLAN Routing
# after LR is deleted in the project.
project.set_vxlan_routing(False)
self._vnc_lib.project_update(project)
def test_vxlan_update_failure_for_lr(self):
project = self._vnc_lib.project_read(
fq_name=['default-domain', 'default-project'])
project.set_vxlan_routing(True)
self._vnc_lib.project_update(project)
mock_zk = self._api_server._db_conn._zk_db
# Create Logical Router
lr1 = LogicalRouter('router-test-v4-%s' % self.id(), project)
lr1.set_vxlan_network_identifier('5003')
lr1_uuid = self._vnc_lib.logical_router_create(lr1)
lr1_read = self._vnc_lib.logical_router_read(id=lr1_uuid)
vxlan_id1 = lr1_read.get_vxlan_network_identifier()
self.assertEqual(vxlan_id1, '5003')
lr2 = LogicalRouter('router-test-v4-%s-2' % self.id(), project)
lr2.set_vxlan_network_identifier('5004')
lr2_uuid = self._vnc_lib.logical_router_create(lr2)
lr2_read = self._vnc_lib.logical_router_read(id=lr2_uuid)
vxlan_id2 = lr2_read.get_vxlan_network_identifier()
self.assertEqual(vxlan_id2, '5004')
lr2.set_vxlan_network_identifier('5003')
with ExpectedException(BadRequest):
self._vnc_lib.logical_router_update(lr2)
lr_read = self._vnc_lib.logical_router_read(id=lr2_uuid)
vxlan_id = lr_read.get_vxlan_network_identifier()
self.assertEqual(vxlan_id, '5004')
int_vn_name = get_lr_internal_vn_name(lr2_uuid)
int_vn_fqname = ['default-domain', 'default-project', int_vn_name]
self.assertEqual(':'.join(int_vn_fqname) + "_vxlan",
mock_zk.get_vn_from_id(int(vxlan_id)))
self._vnc_lib.logical_router_delete(id=lr1_uuid)
self._vnc_lib.logical_router_delete(id=lr2_uuid)
def test_change_from_snat_to_vxlan(self):
project = self._vnc_lib.project_read(
fq_name=['default-domain', 'default-project'])
# Create Logical Router enabled for SNAT.
lr = LogicalRouter('router-test-snat-to-vxlan-%s' % (self.id()),
project)
lr.set_logical_router_type('snat-routing')
lr_uuid = self._vnc_lib.logical_router_create(lr)
lr = self._vnc_lib.logical_router_read(id=lr_uuid)
logger.debug('Created Logical Router ')
lr.set_logical_router_type('vxlan-routing')
with ExpectedException(BadRequest):
self._vnc_lib.logical_router_update(lr)
logger.debug('PASS: Could not update LR from SNAT to VXLAN')
def create_lr(self, lrname, vns, prs, vmis):
lr_fq_name = ['default-domain', 'default-project', lrname]
lr = LogicalRouter(fq_name=lr_fq_name,
parent_type='project',
logical_router_type='vxlan-routing')
for pr in prs:
probj = self._vnc_lib.physical_router_read(id=pr.get_uuid())
lr.add_physical_router(probj)
for vn in vns:
vminame = 'vmi-lr-to-vn' + vn.get_display_name()
fq_name1 = ['default-domain', 'default-project', vminame]
vmi = VirtualMachineInterface(fq_name=fq_name1,
parent_type='project')
vmi.set_virtual_network(vn)
self._vnc_lib.virtual_machine_interface_create(vmi)
vmis[vminame] = vmi
lr.add_virtual_machine_interface(vmi)
lr_uuid = self._vnc_lib.logical_router_create(lr)
return lr, self._vnc_lib.logical_router_read(id=lr_uuid)
def create_all(self):
self.create_features([
'underlay-ip-clos', 'overlay-bgp', 'l2-gateway', 'l3-gateway',
'vn-interconnect'
])
self.create_physical_roles(['leaf', 'spine', 'pnf'])
self.create_overlay_roles(['crb-gateway', 'pnf-servicechain'])
self.create_role_definitions([
AttrDict({
'name': 'crb-gateway-spine',
'physical_role': 'spine',
'overlay_role': 'crb-gateway',
'features': ['l3-gateway', 'vn-interconnect'],
'feature_configs': None
}),
AttrDict({
'name': 'pnf-service-chain',
'physical_role': 'pnf',
'overlay_role': 'pnf-servicechain',
'features': ['l3-gateway', 'vn-interconnect'],
'feature_configs': None
})
])
self.jt = self.create_job_template('job-template-1' + self.id())
self.fabric = self.create_fabric('fabric-1' + self.id())
self.np1, self.rc1 = self.create_node_profile(
'node-profile-1' + self.id(),
device_family='junos-qfx',
role_mappings=[
AttrDict({
'physical_role': 'spine',
'rb_roles': ['crb-gateway']
})
],
job_template=self.jt)
self.np2, self.rc2 = self.create_node_profile(
'node-profile-2' + self.id(),
device_family='junos-srx',
role_mappings=[
AttrDict({
'physical_role': 'pnf',
'rb_roles': ['pnf-servicechain']
})
],
job_template=self.jt)
rtr1_name = 'router1' + self.id()
self.bgp_router1, self.pr1 = self.create_router(
rtr1_name,
'1.1.1.1',
product='qfx10008',
family='junos-qfx',
role='spine',
rb_roles=['crb-gateway', 'DCI-Gateway'],
physical_role=self.physical_roles['spine'],
overlay_role=self.overlay_roles['crb-gateway'],
fabric=self.fabric,
node_profile=self.np1)
rtr2_name = 'router2' + self.id()
self.bgp_router2, self.pr2 = self.create_router(
rtr2_name,
'1.1.1.2',
product='qfx10008',
family='junos-qfx',
role='pnf',
rb_roles=['PNF-Servicechain'],
physical_role=self.physical_roles['pnf'],
overlay_role=self.overlay_roles['pnf-servicechain'],
fabric=self.fabric,
node_profile=self.np2)
pi1_0_name = "xe-0/0/0"
self.pi1_0 = PhysicalInterface(pi1_0_name, parent_obj=self.pr1)
self.pi1_0_fq = ':'.join(self.pi1_0.fq_name)
self._vnc_lib.physical_interface_create(self.pi1_0)
pi1_1_name = "xe-0/0/1"
self.pi1_1 = PhysicalInterface(pi1_1_name, parent_obj=self.pr1)
self.pi1_1_fq = ':'.join(self.pi1_1.fq_name)
self._vnc_lib.physical_interface_create(self.pi1_1)
pi2_0_name = "xe-0/0/0"
self.pi2_0 = PhysicalInterface(pi2_0_name, parent_obj=self.pr2)
self._vnc_lib.physical_interface_create(self.pi2_0)
pi2_1_name = "xe-0/0/1"
self.pi2_1 = PhysicalInterface(pi2_1_name, parent_obj=self.pr2)
self._vnc_lib.physical_interface_create(self.pi2_1)
self.vn1 = self.create_vn('1', '1.1.1.0')
lr1_name = 'lr1-' + self.id()
lr1_fq_name = ['default-domain', 'default-project', lr1_name]
self.lr1 = LogicalRouter(fq_name=lr1_fq_name,
parent_type='project',
logical_router_type='vxlan-routing',
vxlan_network_identifier='3000')
self.lr1.set_physical_router(self.pr1)
self._vnc_lib.logical_router_create(self.lr1)
lr2_name = 'lr2-' + self.id()
lr2_fq_name = ['default-domain', 'default-project', lr2_name]
self.lr2 = LogicalRouter(fq_name=lr2_fq_name,
parent_type='project',
logical_router_type='vxlan-routing',
vxlan_network_identifier='4000')
self.lr2.set_physical_router(self.pr2)
self._vnc_lib.logical_router_create(self.lr2)
fq_name = ['default-domain', 'default-project', 'vmi-' + self.id()]
self.vmi = VirtualMachineInterface(fq_name=fq_name,
parent_type='project')
self.vmi.set_virtual_network(self.vn1)
self._vnc_lib.virtual_machine_interface_create(self.vmi)
self.lr1.add_virtual_machine_interface(self.vmi)
self._vnc_lib.logical_router_update(self.lr1)
class TestTransactionsDM(TestAnsibleCommonDM):
def setUp(self, extra_config_knobs=None):
super(TestTransactionsDM,
self).setUp(extra_config_knobs=extra_config_knobs)
self.create_all()
def tearDown(self):
self.delete_all()
super(TestTransactionsDM, self).tearDown()
@retries(5, hook=retry_exc_handler)
def chk_trans_info(self,
trans_id=None,
pr_name=None,
trans_descr=None,
allow_update=False):
if pr_name:
t_id, t_descr = FakeJobHandler.get_dev_transaction_info(pr_name)
else:
t_id, t_descr = FakeJobHandler.get_transaction_info()
if allow_update and 'Create' in trans_descr and 'Update' in t_descr:
trans_descr = trans_descr.replace('Create', 'Update')
if 'DCI' in trans_descr and trans_descr != t_descr and pr_name:
print("Transaction mistmatch {} != {}".format(
trans_descr, t_descr))
# sometimes due to timing, PR transaction gets updated.
trans_descr = "Bgp Router '{}' Update".format(pr_name)
self.assertEqual(trans_descr, t_descr)
if trans_id:
self.assertEqual(trans_id, t_id)
print("TRANSACTION: {}".format(trans_descr))
return t_id, t_descr
def check_trans_info(self,
obj_type=None,
oper=None,
obj_name=None,
trans_id=None,
pr_name=None,
trans_descr=None,
allow_update=False):
trans_descr = trans_descr or "{} '{}' {}".format(
obj_type, obj_name, oper)
time.sleep(1)
return self.chk_trans_info(trans_id=trans_id,
pr_name=pr_name,
trans_descr=trans_descr,
allow_update=allow_update)
def test_update_bgp_router(self):
self.bgp_router1.set_display_name("foo")
self._vnc_lib.bgp_router_update(self.bgp_router1)
self.check_trans_info('Bgp Router',
'Update',
self.bgp_router1.name,
pr_name=self.bgp_router1.name)
def test_create_logical_router(self):
lr_name = 'lr-' + self.id()
lr_fq_name = ['default-domain', 'default-project', lr_name]
lr = LogicalRouter(fq_name=lr_fq_name,
parent_type='project',
logical_router_type='vxlan-routing',
vxlan_network_identifier='5000')
lr.set_physical_router(self.pr1)
self._vnc_lib.logical_router_create(lr)
self.check_trans_info('Logical Router',
'Create',
lr_name,
pr_name=self.pr1.name)
lr.add_virtual_machine_interface(self.vmi)
self._vnc_lib.logical_router_update(lr)
self.check_trans_info('Logical Router',
'Update',
lr_name,
pr_name=self.pr1.name)
self._vnc_lib.logical_router_delete(id=lr.uuid)
self.check_trans_info('Logical Router',
'Delete',
lr_name,
pr_name=self.pr1.name)
def test_create_vpg(self):
device_name = self.pr1.get_fq_name()[-1]
fabric_name = self.fabric.get_fq_name()[-1]
phy_int_name = self.pi1_0.get_fq_name()[-1]
vpg_name = "vpg-" + self.id()
vlan_tag = 10
vmi = VirtualMachineInterface(vpg_name + "-tagged-" + str(vlan_tag),
parent_type='project',
fq_name=[
"default-domain", "default-project",
vpg_name + "-tagged-" + str(vlan_tag)
])
vmi_profile = \
"{\"local_link_information\":[{\"switch_id\":\"%s\",\"port_id\":"\
"\"%s\",\"switch_info\":\"%s\",\"fabric\":\"%s\"}]}" % \
(phy_int_name, phy_int_name, device_name, fabric_name)
vmi_bindings = {
"key_value_pair": [{
"key": "vnic_type",
"value": "baremetal"
}, {
"key": "vif_type",
"value": "vrouter"
}, {
"key": "vpg",
"value": vpg_name
}, {
"key": "profile",
"value": vmi_profile
}]
}
vmi.set_virtual_machine_interface_bindings(vmi_bindings)
vmi_properties = {"sub_interface_vlan_tag": vlan_tag}
vmi.set_virtual_machine_interface_properties(vmi_properties)
vmi.set_virtual_network(self.vn1)
sg_name = 'sg-1' + self.id()
project = self._vnc_lib.project_read(
['default-domain', 'default-project'])
sg = SecurityGroup(name=sg_name, parent_obj=project)
self._vnc_lib.security_group_create(sg)
# now create a VPG
vpg = VirtualPortGroup(vpg_name, parent_obj=self.fabric)
vpg.set_security_group(sg)
self._vnc_lib.virtual_port_group_create(vpg)
self._vnc_lib.virtual_machine_interface_create(vmi)
self.check_trans_info('Virtual Port Group',
'Create',
vpg_name,
allow_update=True)
# Update VPG
vpg.set_virtual_machine_interface_list([{'uuid': vmi.get_uuid()}])
self._vnc_lib.virtual_port_group_update(vpg)
self.check_trans_info('Virtual Port Group', 'Update', vpg_name)
# Update Security Group
sg = self._vnc_lib.security_group_read(sg.get_fq_name())
rule1 = self.build_acl_rule(0, 65535, 'egress', 'icmp', 'IPv4')
sg_rule1 = self._security_group_rule_build(rule1, sg.get_fq_name_str())
self._security_group_rule_append(sg, sg_rule1)
self._vnc_lib.security_group_update(sg)
self.check_trans_info('Security Group', 'Update', sg_name)
self._vnc_lib.virtual_machine_interface_delete(id=vmi.uuid)
self.check_trans_info('Virtual Port Group', 'Delete', vpg_name)
self._vnc_lib.virtual_port_group_delete(id=vpg.uuid)
def test_create_dci(self):
dci_name = "test-dci" + self.id()
dci = DataCenterInterconnect(dci_name)
dci.add_logical_router(self.lr1)
self._vnc_lib.data_center_interconnect_create(dci)
self.check_trans_info('DCI', 'Create', dci_name, pr_name=self.pr1.name)
dci.del_logical_router(self.lr1)
self._vnc_lib.data_center_interconnect_update(dci)
self.check_trans_info('DCI', 'Update', dci_name, pr_name=self.pr1.name)
dci.add_logical_router(self.lr1)
self._vnc_lib.data_center_interconnect_update(dci)
self._vnc_lib.data_center_interconnect_delete(id=dci.uuid)
self.check_trans_info('DCI', 'Delete', dci_name, pr_name=self.pr1.name)
def test_create_service_instance(self):
sas_name = 'sas-1' + self.id()
sas_fq_name = ['default-global-system-config', sas_name]
sas = ServiceApplianceSet(
fq_name=sas_fq_name,
parent_type='global-system-config',
service_appliance_set_virtualization_type='physical-device')
self._vnc_lib.service_appliance_set_create(sas)
sa_name = 'sa-1' + self.id()
sa_fq_name = ['default-global-system-config', sas_name, sa_name]
sa = ServiceAppliance(
fq_name=sa_fq_name,
parent_type='service-appliance-set',
service_appliance_virtualization_type='physical-device')
sa.set_service_appliance_properties(
KeyValuePairs([
KeyValuePair(key='left-attachment-point', value=self.pi1_0_fq),
KeyValuePair(key='right-attachment-point', value=self.pi1_1_fq)
]))
attr = ServiceApplianceInterfaceType(interface_type='left')
sa.add_physical_interface(self.pi2_0, attr)
attr = ServiceApplianceInterfaceType(interface_type='right')
sa.add_physical_interface(self.pi2_1, attr)
self._vnc_lib.service_appliance_create(sa)
tid, td = self.check_trans_info('Service Appliance',
'Create',
sa_name,
pr_name=self.pr1.name)
st_name = 'st-1' + self.id()
st_fq_name = ['default-domain', st_name]
st = ServiceTemplate(fq_name=st_fq_name)
st.set_service_appliance_set(sas)
st.set_service_config_managed(False)
svc_properties = ServiceTemplateType()
svc_properties.set_service_virtualization_type('physical-device')
if_type = ServiceTemplateInterfaceType(interface_type='left')
svc_properties.add_interface_type(if_type)
if_type = ServiceTemplateInterfaceType(interface_type='right')
svc_properties.add_interface_type(if_type)
st.set_service_template_properties(svc_properties)
self._vnc_lib.service_template_create(st)
self.check_trans_info(trans_id=tid,
trans_descr=td,
pr_name=self.pr1.name)
si_name = 'si-' + self.id()
si_fqn = ['default-domain', 'default-project', si_name]
si = ServiceInstance(fq_name=si_fqn)
si.fq_name = si_fqn
si.add_service_template(st)
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.set_annotations(kvps)
props = ServiceInstanceType()
props.set_service_virtualization_type('physical-device')
props.set_ha_mode("active-standby")
si.set_service_instance_properties(props)
self._vnc_lib.service_instance_create(si)
self.check_trans_info(trans_id=tid,
trans_descr=td,
pr_name=self.pr1.name)
pt_name = 'pt-' + self.id()
pt = PortTuple(pt_name, parent_obj=si)
pt.add_logical_router(self.lr1)
pt.add_logical_router(self.lr2)
kvp_array = []
kvp = KeyValuePair("left-lr", self.lr1.uuid)
kvp_array.append(kvp)
kvp = KeyValuePair("right-lr", self.lr2.uuid)
kvp_array.append(kvp)
kvps = KeyValuePairs()
kvps.set_key_value_pair(kvp_array)
pt.set_annotations(kvps)
self._vnc_lib.port_tuple_create(pt)
self.check_trans_info('Service Instance',
'Create',
si_name,
pr_name=self.pr1.name)
self._vnc_lib.port_tuple_delete(id=pt.uuid)
self.check_trans_info('Service Instance',
'Delete',
si_name,
pr_name=self.pr1.name)
self._vnc_lib.service_appliance_delete(fq_name=sa.fq_name)
self.check_trans_info('Service Appliance',
'Delete',
sa_name,
pr_name=self.pr1.name)
def create_all(self):
self.create_features([
'underlay-ip-clos', 'overlay-bgp', 'l2-gateway', 'l3-gateway',
'vn-interconnect'
])
self.create_physical_roles(['leaf', 'spine', 'pnf'])
self.create_overlay_roles(['crb-gateway', 'pnf-servicechain'])
self.create_role_definitions([
AttrDict({
'name': 'crb-gateway-spine',
'physical_role': 'spine',
'overlay_role': 'crb-gateway',
'features': ['l3-gateway', 'vn-interconnect'],
'feature_configs': None
}),
AttrDict({
'name': 'pnf-service-chain',
'physical_role': 'pnf',
'overlay_role': 'pnf-servicechain',
'features': ['l3-gateway', 'vn-interconnect'],
'feature_configs': None
})
])
self.jt = self.create_job_template('job-template-1' + self.id())
self.fabric = self.create_fabric('fabric-1' + self.id())
self.np1, self.rc1 = self.create_node_profile(
'node-profile-1' + self.id(),
device_family='junos-qfx',
role_mappings=[
AttrDict({
'physical_role': 'spine',
'rb_roles': ['crb-gateway']
})
],
job_template=self.jt)
self.np2, self.rc2 = self.create_node_profile(
'node-profile-2' + self.id(),
device_family='junos-srx',
role_mappings=[
AttrDict({
'physical_role': 'pnf',
'rb_roles': ['pnf-servicechain']
})
],
job_template=self.jt)
rtr1_name = 'router1' + self.id()
self.bgp_router1, self.pr1 = self.create_router(
rtr1_name,
'1.1.1.1',
product='qfx10008',
family='junos-qfx',
role='spine',
rb_roles=['crb-gateway', 'DCI-Gateway'],
physical_role=self.physical_roles['spine'],
overlay_role=self.overlay_roles['crb-gateway'],
fabric=self.fabric,
node_profile=self.np1)
rtr2_name = 'router2' + self.id()
self.bgp_router2, self.pr2 = self.create_router(
rtr2_name,
'1.1.1.2',
product='qfx10008',
family='junos-qfx',
role='pnf',
rb_roles=['PNF-Servicechain'],
physical_role=self.physical_roles['pnf'],
overlay_role=self.overlay_roles['pnf-servicechain'],
fabric=self.fabric,
node_profile=self.np2)
pi1_0_name = "xe-0/0/0"
self.pi1_0 = PhysicalInterface(pi1_0_name, parent_obj=self.pr1)
self.pi1_0_fq = ':'.join(self.pi1_0.fq_name)
self._vnc_lib.physical_interface_create(self.pi1_0)
pi1_1_name = "xe-0/0/1"
self.pi1_1 = PhysicalInterface(pi1_1_name, parent_obj=self.pr1)
self.pi1_1_fq = ':'.join(self.pi1_1.fq_name)
self._vnc_lib.physical_interface_create(self.pi1_1)
pi2_0_name = "xe-0/0/0"
self.pi2_0 = PhysicalInterface(pi2_0_name, parent_obj=self.pr2)
self._vnc_lib.physical_interface_create(self.pi2_0)
pi2_1_name = "xe-0/0/1"
self.pi2_1 = PhysicalInterface(pi2_1_name, parent_obj=self.pr2)
self._vnc_lib.physical_interface_create(self.pi2_1)
self.vn1 = self.create_vn('1', '1.1.1.0')
lr1_name = 'lr1-' + self.id()
lr1_fq_name = ['default-domain', 'default-project', lr1_name]
self.lr1 = LogicalRouter(fq_name=lr1_fq_name,
parent_type='project',
logical_router_type='vxlan-routing',
vxlan_network_identifier='3000')
self.lr1.set_physical_router(self.pr1)
self._vnc_lib.logical_router_create(self.lr1)
lr2_name = 'lr2-' + self.id()
lr2_fq_name = ['default-domain', 'default-project', lr2_name]
self.lr2 = LogicalRouter(fq_name=lr2_fq_name,
parent_type='project',
logical_router_type='vxlan-routing',
vxlan_network_identifier='4000')
self.lr2.set_physical_router(self.pr2)
self._vnc_lib.logical_router_create(self.lr2)
fq_name = ['default-domain', 'default-project', 'vmi-' + self.id()]
self.vmi = VirtualMachineInterface(fq_name=fq_name,
parent_type='project')
self.vmi.set_virtual_network(self.vn1)
self._vnc_lib.virtual_machine_interface_create(self.vmi)
self.lr1.add_virtual_machine_interface(self.vmi)
self._vnc_lib.logical_router_update(self.lr1)
def delete_all(self):
self._vnc_lib.logical_router_delete(id=self.lr1.uuid)
self._vnc_lib.logical_router_delete(id=self.lr2.uuid)
self._vnc_lib.virtual_machine_interface_delete(id=self.vmi.uuid)
self._vnc_lib.physical_interface_delete(id=self.pi1_0.uuid)
self._vnc_lib.physical_interface_delete(id=self.pi1_1.uuid)
self._vnc_lib.physical_interface_delete(id=self.pi2_0.uuid)
self._vnc_lib.physical_interface_delete(id=self.pi2_1.uuid)
self.delete_routers(None, self.pr1)
self.wait_for_routers_delete(None, self.pr1.get_fq_name())
self._vnc_lib.bgp_router_delete(id=self.bgp_router1.uuid)
self.delete_routers(None, self.pr2)
self.wait_for_routers_delete(None, self.pr2.get_fq_name())
self._vnc_lib.bgp_router_delete(id=self.bgp_router2.uuid)
self._vnc_lib.virtual_network_delete(id=self.vn1.uuid)
self._vnc_lib.role_config_delete(id=self.rc1.uuid)
self._vnc_lib.role_config_delete(id=self.rc2.uuid)
self._vnc_lib.node_profile_delete(id=self.np1.uuid)
self._vnc_lib.node_profile_delete(id=self.np2.uuid)
self._vnc_lib.fabric_delete(id=self.fabric.uuid)
self._vnc_lib.job_template_delete(id=self.jt.uuid)
self.delete_role_definitions()
self.delete_overlay_roles()
self.delete_physical_roles()
self.delete_features()
self.wait_for_features_delete()
def build_acl_rule(self, pmin, pmax, direction, proto, etype):
rule = {}
rule['port_min'] = pmin
rule['port_max'] = pmax
rule['direction'] = direction
rule['ip_prefix'] = None
rule['protocol'] = proto
rule['ether_type'] = etype
return rule
def _load_init_data(self):
"""
Load init data for job playbooks.
This function loads init data from a data file specified by the
argument '--fabric_ansible_dir' to the database. The data file
must be in JSON format and follow the format below
"my payload": {
"object_type": "tag"
"objects": [
{
"fq_name": [
"fabric=management_ip"
],
"name": "fabric=management_ip",
"tag_type_name": "fabric",
"tag_value": "management_ip"
}
]
}
"""
try:
json_data = self._load_json_data()
if json_data is None:
self._logger.error('Unable to load init data')
return
for item in json_data.get("data"):
object_type = item.get("object_type")
# Get the class name from object type
cls_name = CamelCase(object_type)
# Get the class object
cls_ob = str_to_class(cls_name, resource_client.__name__)
# saving the objects to the database
for obj in item.get("objects"):
instance_obj = cls_ob.from_dict(**obj)
# create/update the object
fq_name = instance_obj.get_fq_name()
try:
uuid_id = self._vnc_api.fq_name_to_id(
object_type, fq_name)
if object_type == "tag":
continue
instance_obj.set_uuid(uuid_id)
# Update config json inside role-config object
if object_type == 'role-config':
role_config_obj = self._vnc_api.\
role_config_read(id=uuid_id)
cur_config_json = json.loads(
role_config_obj.get_role_config_config())
def_config_json = json.loads(
instance_obj.get_role_config_config())
def_config_json.update(cur_config_json)
instance_obj.set_role_config_config(
json.dumps(def_config_json))
if object_type != 'telemetry-profile' and \
object_type != 'sflow-profile' and \
object_type != 'device-functional-group':
self._vnc_api._object_update(
object_type, instance_obj)
except NoIdError:
self._vnc_api._object_create(object_type, instance_obj)
for item in json_data.get("refs"):
from_type = item.get("from_type")
from_fq_name = item.get("from_fq_name")
from_uuid = self._vnc_api.fq_name_to_id(
from_type, from_fq_name)
to_type = item.get("to_type")
to_fq_name = item.get("to_fq_name")
to_uuid = self._vnc_api.fq_name_to_id(to_type, to_fq_name)
self._vnc_api.ref_update(from_type, from_uuid, to_type,
to_uuid, to_fq_name, 'ADD')
except Exception as e:
err_msg = 'error while loading init data: %s\n' % str(e)
err_msg += detailed_traceback()
self._logger.error(err_msg)
# create VN and IPAM for IPV6 link-local addresses
ipv6_link_local_nw = '_internal_vn_ipv6_link_local'
self._create_ipv6_ll_ipam_and_vn(self._vnc_api, ipv6_link_local_nw)
# - fetch list of all the physical routers
# - check physical and overlay role associated with each PR
# - create ref between physical_role and physical_router object,
# if PR is assigned with a specific physical role
# - create ref between overlay_roles and physical_router object,
# if PR is assigned with specific overlay roles
obj_list = self._vnc_api._objects_list('physical-router')
pr_list = obj_list.get('physical-routers')
for pr in pr_list or []:
try:
pr_obj = self._vnc_api.\
physical_router_read(id=pr.get('uuid'))
physical_role = pr_obj.get_physical_router_role()
overlay_roles = pr_obj.get_routing_bridging_roles()
if overlay_roles is not None:
overlay_roles = overlay_roles.get_rb_roles()
if physical_role:
try:
physical_role_uuid = self._vnc_api.\
fq_name_to_id('physical_role',
['default-global-system-config',
physical_role])
if physical_role_uuid:
self._vnc_api.ref_update('physical-router',
pr.get('uuid'),
'physical-role',
physical_role_uuid, None,
'ADD')
except NoIdError:
pass
if overlay_roles:
for overlay_role in overlay_roles or []:
try:
overlay_role_uuid = self._vnc_api.\
fq_name_to_id('overlay_role',
['default-global-system-config',
overlay_role.lower()])
if overlay_role_uuid:
self._vnc_api.ref_update(
'physical-router', pr.get('uuid'),
'overlay-role', overlay_role_uuid, None,
'ADD')
except NoIdError:
pass
except NoIdError:
pass
# handle replacing master-LR as <fab_name>-master-LR here
# as part of in-place cluster update. Copy the master-LR
# and also its associated vns and their annotations here
master_lr_obj = None
try:
master_lr_obj = self._vnc_api.logical_router_read(
fq_name=['default-domain', 'default-project', 'master-LR'])
except NoIdError:
try:
master_lr_obj = self._vnc_api.logical_router_read(
fq_name=['default-domain', 'admin', 'master-LR'])
except NoIdError:
pass
if master_lr_obj:
vmi_refs = master_lr_obj.get_virtual_machine_interface_refs() or []
# get existing pr refs
pr_refs = master_lr_obj.get_physical_router_refs() or []
fabric_refs = master_lr_obj.get_fabric_refs() or []
perms2 = master_lr_obj.get_perms2()
fab_fq_name = None
try:
# This has to happen before creating fab-master-LR as
# otherwise it will fail creation
# of fab-master-lr with annotations having master-lr uuid
# Now delete master-LR object
# this will delete lr annotations from fabric in
# corresponding VNs if they exist
self._vnc_api.logical_router_delete(
id=master_lr_obj.get_uuid())
# try to obtain the fabric refs either by fabric ref if one
# is available or from pr_refs if available
if pr_refs and not fabric_refs:
# this is assuming that even though there can be
# multiple pr refs, a LR cannot have more than
# one fabric refs. So a random pr chosen in the pr
# refs list will have the same fabric name as the other
# prs in the list
pr_ref = pr_refs[-1]
pr_obj = self._vnc_api.physical_router_read(id=pr_ref.get(
'uuid', self._vnc_api.fq_name_to_id(pr_ref.get('to'))))
fabric_refs = pr_obj.get_fabric_refs() or []
if fabric_refs:
fabric_ref = fabric_refs[-1]
fab_fq_name = fabric_ref.get(
'to',
self._vnc_api.id_to_fq_name(fabric_ref.get('uuid')))
# if fab_fq_name is not derivable or was not present, then
# skip creating fab_name-master-LR as fabric information
# is not available
# if fab_fq_name is available, copy necessary refs from prev.
# master LR, create new fab_name-master-LR and this will update
# VN annotations accordingly.
if fab_fq_name:
def_project = self._vnc_api.project_read(
['default-domain', 'default-project'])
fab_name = fab_fq_name[-1]
lr_fq_name = [
'default-domain', 'default-project',
fab_name + '-master-LR'
]
fab_master_lr_obj = LogicalRouter(
name=lr_fq_name[-1],
fq_name=lr_fq_name,
logical_router_gateway_external=False,
logical_router_type='vxlan-routing',
parent_obj=def_project)
perms2.set_global_access(PERMS_RWX)
fab_master_lr_obj.set_perms2(perms2)
fab_master_lr_obj.set_virtual_machine_interface_list(
vmi_refs)
fab_master_lr_obj.set_physical_router_list(pr_refs)
fab_master_lr_obj.set_fabric_list(fabric_refs)
self._vnc_api.logical_router_create(fab_master_lr_obj)
except NoIdError:
pass
except Exception as exc:
err_msg = "An exception occurred while attempting to " \
"create fabric master-LR: %s " % exc.message
self._logger.warning(err_msg)
# handle deleted job_templates as part of in-place cluster update
to_be_del_jt_names = [
'show_interfaces_template', 'show_config_interfaces_template',
'show_interfaces_by_names_template'
]
for jt_name in to_be_del_jt_names:
try:
self._vnc_api.job_template_delete(
fq_name=['default-global-system-config', jt_name])
except NoIdError:
pass
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 test_same_network_not_attached_to_lr(self):
project = self._vnc_lib.project_read(
['default-domain', 'default-project'])
ipam = self._vnc_lib.network_ipam_read(
['default-domain', 'default-project', 'default-network-ipam'])
# Create subnets
ipam_sn_v4_vn = IpamSubnetType(subnet=SubnetType('11.1.1.0', 24))
# Create VN my-vn
vn = VirtualNetwork('%s-vn' % self.id(), project)
vn.add_network_ipam(ipam, VnSubnetsType([ipam_sn_v4_vn]))
self._vnc_lib.virtual_network_create(vn)
net_obj = self._vnc_lib.virtual_network_read(id=vn.uuid)
# Create v4 Ip object
ip_obj = InstanceIp(name=str(uuid.uuid4()), instance_ip_family='v4')
ip_obj.uuid = ip_obj.name
# Create Port
port_obj = self.create_port(project, net_obj)
# Create Logical Router
lr = LogicalRouter('router-test-v4-%s' % self.id(), project)
lr.set_logical_router_type('snat-routing')
self._vnc_lib.logical_router_create(lr)
# Add Router Interface
lr.add_virtual_machine_interface(port_obj)
self._vnc_lib.logical_router_update(lr)
# set router_external
net_obj.set_router_external(True)
self._vnc_lib.virtual_network_update(net_obj)
with ExpectedException(BadRequest):
lr.add_virtual_network(net_obj)
self._vnc_lib.logical_router_update(lr)
lr.del_virtual_network(net_obj)
lr.del_virtual_machine_interface(port_obj)
self._vnc_lib.logical_router_update(lr)
lr.add_virtual_network(net_obj)
self._vnc_lib.logical_router_update(lr)
# Create Port
port_obj = self.create_port(project, net_obj)
with ExpectedException(BadRequest):
lr.add_virtual_machine_interface(port_obj)
self._vnc_lib.logical_router_update(lr)
self._vnc_lib.logical_router_delete(id=lr.uuid)
def _create_fabric_master_LR(self,
fab_fq_name,
perms2,
fabric_refs=None,
fabric_obj=None,
vmi_refs=None,
pr_refs=None):
def_project = self._vnc_api.project_read(
['default-domain', 'default-project'])
fab_name = fab_fq_name[-1]
lr_fq_name = [
'default-domain', 'default-project', fab_name + '-master-LR'
]
fab_master_lr_obj = LogicalRouter(
name=lr_fq_name[-1],
fq_name=lr_fq_name,
logical_router_gateway_external=False,
logical_router_type='vxlan-routing',
parent_obj=def_project)
perms2.set_global_access(PERMS_RWX)
fab_master_lr_obj.set_perms2(perms2)
if vmi_refs:
fab_master_lr_obj.set_virtual_machine_interface_list(vmi_refs)
if pr_refs:
fab_master_lr_obj.set_physical_router_list(pr_refs)
if fabric_refs:
fab_master_lr_obj.set_fabric_list(fabric_refs)
if fabric_obj:
fab_master_lr_obj.set_fabric(fabric_obj)
self._vnc_api.logical_router_create(fab_master_lr_obj)
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 test_vxlan_routing_for_internal_vn(self):
project = self._vnc_lib.project_read(
fq_name=['default-domain', 'default-project'])
project.set_vxlan_routing(True)
self._vnc_lib.project_update(project)
# Create Logical Router
lr = LogicalRouter('router-test-v4-%s' % self.id(), project)
lr_uuid = self._vnc_lib.logical_router_create(lr)
lr = self._vnc_lib.logical_router_read(id=lr_uuid)
# Check to see whether internal VN for VxLAN Routing is created.
int_vn_name = get_lr_internal_vn_name(lr_uuid)
int_vn_fqname = ['default-domain', 'default-project', int_vn_name]
try:
self._vnc_lib.virtual_network_read(fq_name=int_vn_fqname)
except NoIdError as e:
# Invisible objects do not come up in read
# calls but throws up a exception saying the
# object is invisible but cannot be read, confirming
# the presence of the object. Hack!
if "This object is not visible" not in str(e):
assert (False)
# Check to see if we are not able to attach Ext Gateway when
# VxLAN Routing is enabled.
ext_vn = VirtualNetwork(name=self.id() + '_ext_lr')
ext_vn_uuid = self._vnc_lib.virtual_network_create(ext_vn)
ext_vn = self._vnc_lib.virtual_network_read(id=ext_vn_uuid)
lr.add_virtual_network(ext_vn)
try:
self._vnc_lib.logical_router_update(lr)
self.fail("API allow to add an external gateway to the logical "
"router while the VxLAN routing is enabled")
except BadRequest:
pass
# Check to see if we are not able to disable VxLAN routing in the
# project when there is one LR in the project.
project.set_vxlan_routing(False)
try:
self._vnc_lib.project_update(project)
self.fail("API allows to disable VxLAN routhing while there is a "
"logical router in the project")
except BadRequest:
pass
# Check to see if deleting the VN deletes the internal VN
# that was created.
self._vnc_lib.logical_router_delete(id=lr_uuid)
try:
self._vnc_lib.virtual_network_read(fq_name=int_vn_fqname)
self.fail("Logical router internal virtual network was not "
"removed")
except NoIdError:
pass
# Check to see if we are able to disable VxLAN Routing
# after LR is deleted in the project.
project.set_vxlan_routing(False)
self._vnc_lib.project_update(project)
