def pre_dbe_delete(cls, id, obj_dict, db_conn):
ok, vxlan_routing = cls.is_vxlan_routing_enabled(db_conn, obj_dict)
if not ok:
return (ok, vxlan_routing, None)
if vxlan_routing:
ok, proj_dict = cls.get_parent_project(obj_dict, db_conn)
vn_int_fqname = proj_dict.get('fq_name')
vn_int_name = get_lr_internal_vn_name(obj_dict.get('uuid'))
vn_int_fqname.append(vn_int_name)
vn_int_uuid = db_conn.fq_name_to_uuid('virtual_network',
vn_int_fqname)
api_server = db_conn.get_api_server()
attr_obj = LogicalRouterVirtualNetworkType(
'InternalVirtualNetwork')
attr_dict = attr_obj.__dict__
api_server.internal_request_ref_update(
'logical-router',
obj_dict['uuid'],
'DELETE',
'virtual-network',
vn_int_uuid,
vn_int_fqname,
attr=attr_dict)
api_server.internal_request_delete('virtual-network', vn_int_uuid)
def undo_int_vn_delete():
return cls.create_intvn_and_ref(obj_dict, db_conn)
get_context().push_undo(undo_int_vn_delete)
return True, '', None
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_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)
logger.debug('PASS - test_vxlan_update_for_lr')
def pre_dbe_delete(cls, id, obj_dict, db_conn):
ok, vxlan_routing = cls.is_vxlan_routing_enabled(db_conn, obj_dict)
if not ok:
return (ok, vxlan_routing, None)
if vxlan_routing:
ok, proj_dict = cls.get_parent_project(obj_dict, db_conn)
vn_int_fqname = proj_dict.get('fq_name')
vn_int_name = get_lr_internal_vn_name(obj_dict.get('uuid'))
vn_int_fqname.append(vn_int_name)
vn_int_uuid = db_conn.fq_name_to_uuid('virtual_network',
vn_int_fqname)
api_server = db_conn.get_api_server()
attr_obj = LogicalRouterVirtualNetworkType(
'InternalVirtualNetwork')
attr_dict = attr_obj.__dict__
api_server.internal_request_ref_update('logical-router',
obj_dict['uuid'],
'DELETE',
'virtual-network',
vn_int_uuid,
vn_int_fqname,
attr=attr_dict)
api_server.internal_request_delete('virtual-network', vn_int_uuid)
def undo_int_vn_delete():
return cls.create_intvn_and_ref(obj_dict, db_conn)
get_context().push_undo(undo_int_vn_delete)
return True, '', None
def test_vn_internal_lr(self):
proj_obj = self._vnc_lib.project_read(
fq_name=['default-domain', 'default-project'])
proj_obj.set_vxlan_routing(True)
self._vnc_lib.project_update(proj_obj)
lr_name = self.id() + '_logicalrouter'
lr = LogicalRouter(lr_name)
rtgt_list = RouteTargetList(route_target=['target:3:1'])
lr.set_configured_route_target_list(rtgt_list)
self._vnc_lib.logical_router_create(lr)
lr_read = self._vnc_lib.logical_router_read(fq_name=lr.get_fq_name())
lr_target = self.check_lr_target(lr_read.get_fq_name())
ivn_name = get_lr_internal_vn_name(lr_read.uuid)
lr_ivn_read = self._vnc_lib.virtual_network_read(
fq_name=proj_obj.get_fq_name()+[ivn_name])
ri_name = self.get_ri_name(lr_ivn_read)
self.check_route_target_in_routing_instance(
ri_name,rtgt_list.get_route_target())
# change RT and see it is getting updated
rtgt_list.delete_route_target('target:3:1')
rtgt_list.add_route_target('target:4:1')
lr.set_configured_route_target_list(rtgt_list)
self._vnc_lib.logical_router_update(lr)
self.check_route_target_in_routing_instance(
ri_name,rtgt_list.get_route_target())
# cleanup
self._vnc_lib.logical_router_delete(id=lr.uuid)
self.check_lr_is_deleted(uuid=lr.uuid)
self.check_vn_is_deleted(uuid=lr_ivn_read.uuid)
def create_intvn_and_ref(cls, obj_dict):
vn_fq_name = (obj_dict['fq_name'][:-1] +
[get_lr_internal_vn_name(obj_dict['uuid'])])
kwargs = {'id_perms': IdPermsType(user_visible=False)}
vn_property = VirtualNetworkType(forwarding_mode='l3')
if 'vxlan_network_identifier' in obj_dict:
vn_property.set_vxlan_network_identifier(
obj_dict['vxlan_network_identifier'])
kwargs['virtual_network_properties'] = vn_property
rt_list = obj_dict.get(
'configured_route_target_list', {}).get('route_target')
if rt_list:
kwargs['route_target_list'] = RouteTargetList(rt_list)
ok, result = cls.server.get_resource_class(
'virtual_network').locate(vn_fq_name, **kwargs)
if not ok:
return False, result
attr_obj = LogicalRouterVirtualNetworkType('InternalVirtualNetwork')
attr_dict = attr_obj.__dict__
api_server = cls.server
try:
api_server.internal_request_ref_update(
'logical-router',
obj_dict['uuid'],
'ADD',
'virtual-network',
result['uuid'],
result['fq_name'],
attr=attr_dict)
except HttpError as e:
return False, (e.status_code, e.content)
return True, ''
def pre_dbe_delete(cls, id, obj_dict, db_conn):
logical_router_type = cls.check_lr_type(obj_dict)
if logical_router_type == 'vxlan-routing':
vn_int_fqname = (obj_dict['fq_name'][:-1] +
[get_lr_internal_vn_name(obj_dict['uuid'])])
vn_int_uuid = db_conn.fq_name_to_uuid('virtual_network',
vn_int_fqname)
api_server = cls.server
try:
api_server.internal_request_ref_update(
'logical-router',
obj_dict['uuid'],
'DELETE',
'virtual-network',
vn_int_uuid,
vn_int_fqname)
api_server.internal_request_delete('virtual-network',
vn_int_uuid)
except HttpError as e:
if e.status_code != 404:
return False, (e.status_code, e.content), None
except NoIdError:
pass
def undo_int_vn_delete():
return cls.create_intvn_and_ref(obj_dict)
get_context().push_undo(undo_int_vn_delete)
return True, '', None
def test_vn_internal_lr(self):
proj_obj = self._vnc_lib.project_read(
fq_name=['default-domain', 'default-project'])
proj_obj.set_vxlan_routing(True)
self._vnc_lib.project_update(proj_obj)
lr_name = self.id() + '_logicalrouter'
lr = LogicalRouter(lr_name)
rtgt_list = RouteTargetList(route_target=['target:3:1'])
lr.set_configured_route_target_list(rtgt_list)
self._vnc_lib.logical_router_create(lr)
lr_read = self._vnc_lib.logical_router_read(fq_name=lr.get_fq_name())
lr_target = self.check_lr_target(lr_read.get_fq_name())
ivn_name = get_lr_internal_vn_name(lr_read.uuid)
lr_ivn_read = self._vnc_lib.virtual_network_read(
fq_name=proj_obj.get_fq_name()+[ivn_name])
ri_name = self.get_ri_name(lr_ivn_read)
self.check_route_target_in_routing_instance(
ri_name,rtgt_list.get_route_target())
# change RT and see it is getting updated
rtgt_list.delete_route_target('target:3:1')
rtgt_list.add_route_target('target:4:1')
lr.set_configured_route_target_list(rtgt_list)
self._vnc_lib.logical_router_update(lr)
self.check_route_target_in_routing_instance(
ri_name,rtgt_list.get_route_target())
# cleanup
self._vnc_lib.logical_router_delete(id=lr.uuid)
self.check_lr_is_deleted(uuid=lr.uuid)
self.check_vn_is_deleted(uuid=lr_ivn_read.uuid)
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 set_route_target_list(self):
old_rt_list = self.rt_list.copy()
old_bgpvpn_rt_list = self.bgpvpn_rt_list.copy()
old_bgpvpn_import_rt_list = self.bgpvpn_import_rt_list.copy()
old_bgpvpn_export_rt_list = self.bgpvpn_export_rt_list.copy()
# Set the system allocated route target
config_rt_list = self.configured_route_target_list\
or RouteTargetList()
self.rt_list = set(config_rt_list.get_route_target())
# Get BGP VPN's route targets associated to that router
self.bgpvpn_rt_list = set()
self.bgpvpn_import_rt_list = set()
self.bgpvpn_export_rt_list = set()
for bgpvpn_name in self.bgpvpns:
bgpvpn = ResourceBaseST.get_obj_type_map().get('bgpvpn').get(
bgpvpn_name)
if bgpvpn is not None:
self.bgpvpn_rt_list |= bgpvpn.rt_list
self.bgpvpn_import_rt_list |= bgpvpn.import_rt_list
self.bgpvpn_export_rt_list |= bgpvpn.export_rt_list
rt_add = ((self.rt_list - old_rt_list) |
(self.bgpvpn_rt_list - old_bgpvpn_rt_list))
rt_add_import = self.bgpvpn_import_rt_list - old_bgpvpn_import_rt_list
rt_add_export = self.bgpvpn_export_rt_list - old_bgpvpn_export_rt_list
rt_del = (((old_rt_list - self.rt_list) |
(old_bgpvpn_rt_list - self.bgpvpn_rt_list) |
(old_bgpvpn_import_rt_list - self.bgpvpn_import_rt_list) |
(old_bgpvpn_export_rt_list - self.bgpvpn_export_rt_list)) -
(self.rt_list | self.bgpvpn_rt_list
| self.bgpvpn_import_rt_list | self.bgpvpn_export_rt_list))
if not (rt_add or rt_add_import or rt_add_export or rt_del):
return
if self.logical_router_type == 'vxlan-routing':
vn = ':'.join((self.obj.fq_name[:-1] +
[common.get_lr_internal_vn_name(self.obj.uuid)]))
vn_obj = ResourceBaseST.get_obj_type_map().get(
'virtual_network').get(vn)
if vn_obj is not None:
ri_obj = vn_obj.get_primary_routing_instance()
ri_obj.update_route_target_list(rt_add=rt_add,
rt_add_import=rt_add_import,
rt_add_export=rt_add_export,
rt_del=rt_del)
else:
for vn in self.virtual_networks:
vn_obj = ResourceBaseST.get_obj_type_map().get(
'virtual_network').get(vn)
if vn_obj is not None:
ri_obj = vn_obj.get_primary_routing_instance()
ri_obj.update_route_target_list(
rt_add=rt_add,
rt_add_import=rt_add_import,
rt_add_export=rt_add_export,
rt_del=rt_del)
self.delete_route_targets(rt_del)
def pre_dbe_create(cls, tenant_name, obj_dict, db_conn):
ok, result = cls._ensure_lr_dci_association(obj_dict)
if not ok:
return ok, result
ok, result = cls.check_port_gateway_not_in_same_network(
db_conn, obj_dict)
if not ok:
return ok, result
ok, result = cls.is_port_in_use_by_vm(obj_dict, db_conn)
if not ok:
return ok, result
ok, result = cls._check_type(obj_dict)
if not ok:
return ok, result
vxlan_id = cls._check_vxlan_id_in_lr(obj_dict)
logical_router_type = cls.check_lr_type(obj_dict)
if vxlan_id and logical_router_type == 'vxlan-routing':
# If input vxlan_id is not None, that means we need to reserve it.
# First, if vxlan_id is not None, set it in Zookeeper and set the
# undo function for when any failures happen later.
# But first, get the internal_vlan name using which the resource
# in zookeeper space will be reserved.
vxlan_fq_name = '%s:%s_vxlan' % (
':'.join(obj_dict['fq_name'][:-1]),
get_lr_internal_vn_name(obj_dict['uuid']),
)
try:
# Now that we have the internal VN name, allocate it in
# zookeeper only if the resource hasn't been reserved already
cls.vnc_zk_client.alloc_vxlan_id(vxlan_fq_name, int(vxlan_id))
except ResourceExistsError:
msg = ("Cannot set VXLAN_ID: %s, it has already been set" %
vxlan_id)
return False, (400, msg)
def undo_vxlan_id():
cls.vnc_zk_client.free_vxlan_id(int(vxlan_id), vxlan_fq_name)
return True, ""
get_context().push_undo(undo_vxlan_id)
# Check if type of all associated BGP VPN are 'l3'
ok, result = cls.server.get_resource_class(
'bgpvpn').check_router_supports_vpn_type(obj_dict)
if not ok:
return ok, result
# Check if we can reference the BGP VPNs
return cls.server.get_resource_class(
'bgpvpn').check_router_has_bgpvpn_assoc_via_network(obj_dict)
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.set_logical_router_type('vxlan-routing')
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.set_logical_router_type('vxlan-routing')
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 create_intvn_and_ref(cls, obj_dict, db_conn):
ok, proj_dict = db_conn.dbe_read('project', obj_dict['parent_uuid'])
if not ok:
return (ok, proj_dict)
vn_int_name = get_lr_internal_vn_name(obj_dict.get('uuid'))
proj_obj = Project(name=proj_dict.get('fq_name')[-1],
parent_type='domain',
fq_name=proj_dict.get('fq_name'))
vn_obj = VirtualNetwork(name=vn_int_name, parent_obj=proj_obj)
id_perms = IdPermsType(enable=True, user_visible=False)
vn_obj.set_id_perms(id_perms)
int_vn_property = VirtualNetworkType(forwarding_mode='l3')
if 'vxlan_network_identifier' in obj_dict:
vni_id = obj_dict['vxlan_network_identifier']
int_vn_property.set_vxlan_network_identifier(vni_id)
vn_obj.set_virtual_network_properties(int_vn_property)
rt_list = obj_dict.get('configured_route_target_list',
{}).get('route_target')
if rt_list:
vn_obj.set_route_target_list(RouteTargetList(rt_list))
vn_int_dict = json.dumps(vn_obj, default=_obj_serializer_all)
api_server = db_conn.get_api_server()
status, obj = api_server.internal_request_create(
'virtual-network', json.loads(vn_int_dict))
attr_obj = LogicalRouterVirtualNetworkType('InternalVirtualNetwork')
attr_dict = attr_obj.__dict__
api_server.internal_request_ref_update(
'logical-router',
obj_dict['uuid'],
'ADD',
'virtual-network',
obj['virtual-network']['uuid'],
obj['virtual-network']['fq_name'],
attr=attr_dict)
return True, ''
def create_intvn_and_ref(cls, obj_dict, db_conn):
ok, proj_dict = db_conn.dbe_read('project', obj_dict['parent_uuid'])
if not ok:
return (ok, proj_dict)
vn_int_name = get_lr_internal_vn_name(obj_dict.get('uuid'))
proj_obj = Project(name=proj_dict.get('fq_name')[-1],
parent_type='domain',
fq_name=proj_dict.get('fq_name'))
vn_obj = VirtualNetwork(name=vn_int_name, parent_obj=proj_obj)
id_perms = IdPermsType(enable=True, user_visible=False)
vn_obj.set_id_perms(id_perms)
int_vn_property = VirtualNetworkType(forwarding_mode='l3')
if 'vxlan_network_identifier' in obj_dict:
vni_id = obj_dict['vxlan_network_identifier']
int_vn_property.set_vxlan_network_identifier(vni_id)
vn_obj.set_virtual_network_properties(int_vn_property)
rt_list = obj_dict.get('configured_route_target_list',
{}).get('route_target')
if rt_list:
vn_obj.set_route_target_list(RouteTargetList(rt_list))
vn_int_dict = json.dumps(vn_obj, default=_obj_serializer_all)
api_server = db_conn.get_api_server()
status, obj = api_server.internal_request_create(
'virtual-network', json.loads(vn_int_dict))
attr_obj = LogicalRouterVirtualNetworkType('InternalVirtualNetwork')
attr_dict = attr_obj.__dict__
api_server.internal_request_ref_update(
'logical-router',
obj_dict['uuid'],
'ADD',
'virtual-network',
obj['virtual-network']['uuid'],
obj['virtual-network']['fq_name'],
attr=attr_dict)
return True, ''
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(cfgm_common.exceptions.BadRequest) as e:
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)
logger.debug('PASS - test_vxlan_update_failure_for_lr')
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 post_dbe_update(cls, uuid, fq_name, obj_dict, db_conn,
prop_collection_updates=None):
ok, vxlan_routing = cls.is_vxlan_routing_enabled(db_conn, obj_dict)
if not ok:
return ok, vxlan_routing
ok, lr_orig_dict = db_conn.dbe_read(
'logical_router',
obj_dict['uuid'],
obj_fields=['virtual_network_refs'])
if not ok:
return ok, lr_orig_dict
if (obj_dict.get('configured_route_target_list') is None and
'vxlan_network_identifier' not in obj_dict):
return True, ''
if vxlan_routing is True:
vn_int_name = get_lr_internal_vn_name(obj_dict.get('uuid'))
vn_id = None
for vn_ref in lr_orig_dict['virtual_network_refs']:
if (vn_ref.get('attr', {}).get(
'logical_router_virtual_network_type') ==
'InternalVirtualNetwork'):
vn_id = vn_ref.get('uuid')
break
if vn_id is None:
return True, ''
ok, vn_dict = db_conn.dbe_read(
'virtual_network',
vn_id,
obj_fields=['route_target_list',
'fq_name',
'uuid',
'parent_uuid',
'virtual_network_properties'])
if not ok:
return ok, vn_dict
vn_rt_dict_list = vn_dict.get('route_target_list')
vn_rt_list = []
if vn_rt_dict_list:
vn_rt_list = vn_rt_dict_list.get('route_target', [])
lr_rt_list_obj = obj_dict.get('configured_route_target_list')
lr_rt_list = []
if lr_rt_list_obj:
lr_rt_list = lr_rt_list_obj.get('route_target', [])
vxlan_id_in_db = vn_dict.get('virtual_network_properties', {}).get(
'vxlan_network_identifier')
if(vxlan_id_in_db != obj_dict.get('vxlan_network_identifier') or
set(vn_rt_list) != set(lr_rt_list)):
ok, proj_dict = db_conn.dbe_read('project',
vn_dict['parent_uuid'])
if not ok:
return ok, proj_dict
proj_obj = Project(name=vn_dict.get('fq_name')[-2],
parent_type='domain',
fq_name=proj_dict.get('fq_name'))
vn_obj = VirtualNetwork(name=vn_int_name, parent_obj=proj_obj)
if (set(vn_rt_list) != set(lr_rt_list)):
vn_obj.set_route_target_list(lr_rt_list_obj)
# If vxlan_id has been set, we need to propogate it to the
# internal VN.
if vxlan_id_in_db != obj_dict.get('vxlan_network_identifier'):
prop = vn_dict.get('virtual_network_properties', {})
prop['vxlan_network_identifier'] =\
obj_dict['vxlan_network_identifier']
vn_obj.set_virtual_network_properties(prop)
vn_int_dict = json.dumps(vn_obj, default=_obj_serializer_all)
status, obj = cls.server.internal_request_update(
'virtual-network',
vn_dict['uuid'],
json.loads(vn_int_dict))
return True, ''
def pre_dbe_create(cls, tenant_name, obj_dict, db_conn):
ok, result = cls.check_for_external_gateway(db_conn, obj_dict)
if not ok:
return ok, result
ok, result = cls._ensure_lr_dci_association(obj_dict)
if not ok:
return ok, result
ok, result = cls.check_port_gateway_not_in_same_network(db_conn,
obj_dict)
if not ok:
return ok, result
ok, result = cls.is_port_in_use_by_vm(obj_dict, db_conn)
if not ok:
return ok, result
ok, result = cls.is_vxlan_routing_enabled(db_conn, obj_dict)
if not ok:
return ok, result
vxlan_routing = result
vxlan_id = None
vxlan_id = cls._check_vxlan_id_in_lr(obj_dict)
if vxlan_routing and vxlan_id:
# If input vxlan_id is not None, that means we need to reserve it.
# First, check if vxlan_id is set for other fq_name
existing_fq_name = cls.vnc_zk_client.get_vn_from_id(int(vxlan_id))
if existing_fq_name is not None:
msg = ("Cannot set VXLAN_ID: %s, it has already been set" %
vxlan_id)
return False, (400, msg)
# Second, if vxlan_id is not None, set it in Zookeeper and set the
# undo function for when any failures happen later.
# But first, get the internal_vlan name using which the resource
# in zookeeper space will be reserved.
ok, proj_dict = db_conn.dbe_read('project',
obj_dict['parent_uuid'])
if not ok:
return (ok, proj_dict)
vn_int_name = get_lr_internal_vn_name(obj_dict.get('uuid'))
proj_obj = Project(name=proj_dict.get('fq_name')[-1],
parent_type='domain',
fq_name=proj_dict.get('fq_name'))
vn_obj = VirtualNetwork(name=vn_int_name, parent_obj=proj_obj)
try:
vxlan_fq_name = ':'.join(vn_obj.fq_name) + '_vxlan'
# Now that we have the internal VN name, allocate it in
# zookeeper only if the resource hasn't been reserved already
cls.vnc_zk_client.alloc_vxlan_id(vxlan_fq_name, int(vxlan_id))
except ResourceExistsError:
msg = ("Cannot set VXLAN_ID: %s, it has already been set"
% vxlan_id)
return False, (400, msg)
def undo_vxlan_id():
cls.vnc_zk_client.free_vxlan_id(int(vxlan_id), vxlan_fq_name)
return True, ""
get_context().push_undo(undo_vxlan_id)
# Check if type of all associated BGP VPN are 'l3'
ok, result = cls.server.get_resource_class(
'bgpvpn').check_router_supports_vpn_type(obj_dict)
if not ok:
return ok, result
# Check if we can reference the BGP VPNs
return cls.server.get_resource_class(
'bgpvpn').check_router_has_bgpvpn_assoc_via_network(obj_dict)
def pre_dbe_create(cls, tenant_name, obj_dict, db_conn):
ok, result = cls.check_for_external_gateway(db_conn, obj_dict)
if not ok:
return ok, result
ok, result = cls._ensure_lr_dci_association(obj_dict)
if not ok:
return ok, result
ok, result = cls.check_port_gateway_not_in_same_network(
db_conn, obj_dict)
if not ok:
return ok, result
ok, result = cls.is_port_in_use_by_vm(obj_dict, db_conn)
if not ok:
return ok, result
ok, result = cls.is_vxlan_routing_enabled(db_conn, obj_dict)
if not ok:
return ok, result
vxlan_routing = result
vxlan_id = None
vxlan_id = cls._check_vxlan_id_in_lr(obj_dict)
if vxlan_routing and vxlan_id:
# If input vxlan_id is not None, that means we need to reserve it.
# First, check if vxlan_id is set for other fq_name
existing_fq_name = cls.vnc_zk_client.get_vn_from_id(int(vxlan_id))
if existing_fq_name is not None:
msg = ("Cannot set VXLAN_ID: %s, it has already been set" %
vxlan_id)
return False, (400, msg)
# Second, if vxlan_id is not None, set it in Zookeeper and set the
# undo function for when any failures happen later.
# But first, get the internal_vlan name using which the resource
# in zookeeper space will be reserved.
ok, proj_dict = db_conn.dbe_read('project',
obj_dict['parent_uuid'])
if not ok:
return (ok, proj_dict)
vn_int_name = get_lr_internal_vn_name(obj_dict.get('uuid'))
proj_obj = Project(name=proj_dict.get('fq_name')[-1],
parent_type='domain',
fq_name=proj_dict.get('fq_name'))
vn_obj = VirtualNetwork(name=vn_int_name, parent_obj=proj_obj)
try:
vxlan_fq_name = ':'.join(vn_obj.fq_name) + '_vxlan'
# Now that we have the internal VN name, allocate it in
# zookeeper only if the resource hasn't been reserved already
cls.vnc_zk_client.alloc_vxlan_id(vxlan_fq_name, int(vxlan_id))
except ResourceExistsError:
msg = ("Cannot set VXLAN_ID: %s, it has already been set" %
vxlan_id)
return False, (400, msg)
def undo_vxlan_id():
cls.vnc_zk_client.free_vxlan_id(int(vxlan_id), vxlan_fq_name)
return True, ""
get_context().push_undo(undo_vxlan_id)
# Check if type of all associated BGP VPN are 'l3'
ok, result = cls.server.get_resource_class(
'bgpvpn').check_router_supports_vpn_type(obj_dict)
if not ok:
return ok, result
# Check if we can reference the BGP VPNs
return cls.server.get_resource_class(
'bgpvpn').check_router_has_bgpvpn_assoc_via_network(obj_dict)
def post_dbe_update(cls, uuid, fq_name, obj_dict, db_conn,
prop_collection_updates=None):
ok, result = db_conn.dbe_read(
'logical_router',
obj_dict['uuid'],
obj_fields=['virtual_network_refs', 'logical_router_type'])
if not ok:
return ok, result
lr_orig_dict = result
if (obj_dict.get('configured_route_target_list') is None and
'vxlan_network_identifier' not in obj_dict):
return True, ''
logical_router_type_in_db = cls.check_lr_type(lr_orig_dict)
if logical_router_type_in_db == 'vxlan-routing':
# If logical_router_type was set to vxlan-routing in DB,
# it means that an existing LR used for VXLAN
# support was updated to either change the
# vxlan_network_identifer or configured_route_target_list
vn_int_name = get_lr_internal_vn_name(obj_dict.get('uuid'))
vn_id = None
for vn_ref in lr_orig_dict.get('virtual_network_refs') or []:
if (vn_ref.get('attr', {}).get(
'logical_router_virtual_network_type') ==
'InternalVirtualNetwork'):
vn_id = vn_ref.get('uuid')
break
if vn_id is None:
return True, ''
ok, vn_dict = db_conn.dbe_read(
'virtual_network',
vn_id,
obj_fields=['route_target_list',
'fq_name',
'uuid',
'parent_uuid',
'virtual_network_properties'])
if not ok:
return ok, vn_dict
vn_rt_dict_list = vn_dict.get('route_target_list')
vn_rt_list = []
if vn_rt_dict_list:
vn_rt_list = vn_rt_dict_list.get('route_target', [])
lr_rt_list_obj = obj_dict.get('configured_route_target_list')
lr_rt_list = []
if lr_rt_list_obj:
lr_rt_list = lr_rt_list_obj.get('route_target', [])
vxlan_id_in_db = vn_dict.get('virtual_network_properties', {}).get(
'vxlan_network_identifier')
if(vxlan_id_in_db != obj_dict.get('vxlan_network_identifier') or
set(vn_rt_list) != set(lr_rt_list)):
ok, proj_dict = db_conn.dbe_read('project',
vn_dict['parent_uuid'])
if not ok:
return ok, proj_dict
proj_obj = Project(name=vn_dict.get('fq_name')[-2],
parent_type='domain',
fq_name=proj_dict.get('fq_name'))
vn_obj = VirtualNetwork(name=vn_int_name, parent_obj=proj_obj)
if (set(vn_rt_list) != set(lr_rt_list)):
vn_obj.set_route_target_list(lr_rt_list_obj)
# If vxlan_id has been set, we need to propogate it to the
# internal VN.
if vxlan_id_in_db != obj_dict.get('vxlan_network_identifier'):
prop = vn_dict.get('virtual_network_properties', {})
prop['vxlan_network_identifier'] =\
obj_dict['vxlan_network_identifier']
vn_obj.set_virtual_network_properties(prop)
vn_int_dict = json.dumps(vn_obj, default=_obj_serializer_all)
status, obj = cls.server.internal_request_update(
'virtual-network',
vn_dict['uuid'],
json.loads(vn_int_dict))
return True, ''
def test_vxlan_routing_for_internal_vn(self):
global_vrouter_config = GlobalVrouterConfig()
self._vnc_lib.global_vrouter_config_create(global_vrouter_config)
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)
logger.debug('Created Logical Router ')
# 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:
int_vn = 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):
logger.debug(
'FAIL - Internal VN not created for Logical Router')
assert (False)
logger.debug('PASS - Internal VN created for Logical Router')
# 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)
except cfgm_common.exceptions.BadRequest as e:
logger.debug(
'PASS - Not able to attach Ext GW when VxLAN Routing is enabled'
)
else:
logger.debug(
'FAIL - Able to attach Ext GW when VxLAN Routing is enabled')
assert (False)
# 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)
except cfgm_common.exceptions.BadRequest as e:
logger.debug(
'PASS - Checking not updating vxlan_routing in project')
else:
logger.debug(
'FAIL - VxLAN Routing cant be updated in Project when LR exists'
)
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:
int_vn = self._vnc_lib.virtual_network_read(fq_name=int_vn_fqname)
except NoIdError:
logger.debug(
'PASS - Internal VN created for Logical Router is purged')
else:
logger.debug(
'FAIL - Internal VN created for Logical Router is not purged')
assert (False)
# Check to see if we are able to disable VxLAN Routing
# after LR is deleted in the project.
project.set_vxlan_routing(False)
try:
self._vnc_lib.project_update(project)
except cfgm_common.exceptions.BadRequest as e:
logger.debug(
'FAIL - VxLAN Routing update not allowed when LR doesnt exist')
assert (False)
else:
logger.debug('PASS - VxLAN Routing update successful')
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)
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)
logger.debug('Created Logical Router ')
# 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:
int_vn = 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):
logger.debug('FAIL - Internal VN not created for Logical Router')
assert(False)
logger.debug('PASS - Internal VN created for Logical Router')
# 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)
except cfgm_common.exceptions.BadRequest as e:
logger.debug('PASS - Not able to attach Ext GW when VxLAN Routing is enabled')
else:
logger.debug('FAIL - Able to attach Ext GW when VxLAN Routing is enabled')
assert(False)
# 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)
except cfgm_common.exceptions.BadRequest as e:
logger.debug('PASS - Checking not updating vxlan_routing in project')
else:
logger.debug('FAIL - VxLAN Routing cant be updated in Project when LR exists')
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:
int_vn = self._vnc_lib.virtual_network_read(fq_name=int_vn_fqname)
except NoIdError:
logger.debug('PASS - Internal VN created for Logical Router is purged')
else:
logger.debug('FAIL - Internal VN created for Logical Router is not purged')
assert(False)
# Check to see if we are able to disable VxLAN Routing
# after LR is deleted in the project.
project.set_vxlan_routing(False)
try:
self._vnc_lib.project_update(project)
except cfgm_common.exceptions.BadRequest as e:
logger.debug('FAIL - VxLAN Routing update not allowed when LR doesnt exist')
assert(False)
else:
logger.debug('PASS - VxLAN Routing update successful')
