def sanitize_fabric_vmis(self):
self._logger.debug("Starts sanitizing "
"vpg's (%s) fabric vmis" % self.name)
for fabric_vmi_st_name in self.virtual_machine_interfaces:
fabric_vmi_st = \
ResourceBaseST.get_obj_type_map() \
.get('virtual_machine_interface') \
.get(fabric_vmi_st_name)
if fabric_vmi_st is None:
continue
vn_st = \
ResourceBaseST.get_obj_type_map() \
.get('virtual_network') \
.get(fabric_vmi_st.virtual_network)
if vn_st is None:
continue
vn_st.virtual_port_groups.add(self.name)
no_valid_vmi_under_fabric_vmi = True
for vmi_st_name in vn_st.virtual_machine_interfaces:
if vmi_st_name != fabric_vmi_st_name:
vmi_st = \
ResourceBaseST.get_obj_type_map() \
.get('virtual_machine_interface') \
.get(vmi_st_name)
if vmi_st is None:
continue
if vmi_st.get_pi_uuid() in \
self.get_uuids(self.obj.get_physical_interface_refs()):
no_valid_vmi_under_fabric_vmi = False
break
if no_valid_vmi_under_fabric_vmi:
self.delete_fabric_vmi_ref(fabric_vmi_st)
self._logger.debug("Finshed sanitizing "
"vpg's (%s) fabric vmis" % self.name)
def _add_pbf_rules(self):
if not (self.is_left() or self.is_right()):
return
vm_pt_list = self.get_virtual_machine_or_port_tuple()
for vm_pt in vm_pt_list:
if vm_pt.get_service_mode() != 'transparent':
return
for service_chain in ResourceBaseST.get_obj_type_map().get(
'service_chain').values():
if vm_pt.service_instance not in service_chain.service_list:
continue
if not service_chain.created:
continue
if self.is_left():
vn_obj = ResourceBaseST.get_obj_type_map().get(
'virtual_network').locate(service_chain.left_vn)
vn1_obj = vn_obj
else:
vn1_obj = ResourceBaseST.get_obj_type_map().get(
'virtual_network').locate(service_chain.left_vn)
vn_obj = ResourceBaseST.get_obj_type_map().get(
'virtual_network').locate(service_chain.right_vn)
service_name = vn_obj.get_service_name(service_chain.name,
vm_pt.service_instance)
service_ri = ResourceBaseST.get_obj_type_map().get(
'routing_instance').get(service_name)
v4_address, v6_address = vn1_obj.allocate_service_chain_ip(
service_name)
vlan = self._object_db.allocate_service_chain_vlan(
vm_pt.uuid, service_chain.name)
service_chain.add_pbf_rule(self, service_ri, v4_address,
v6_address, vlan)
def get_virtual_networks(self, si_props):
left_vn = None
right_vn = None
st_refs = self.obj.get_service_template_refs()
uuid = st_refs[0]['uuid']
st_obj = ResourceBaseST().read_vnc_obj(uuid,
obj_type='service_template')
st_props = st_obj.get_service_template_properties()
st_if_list = st_props.get_interface_type() or []
si_if_list = si_props.get_interface_list() or []
for (st_if, si_if) in zip(st_if_list, si_if_list):
if st_if.get_service_interface_type() == 'left':
left_vn = si_if.get_virtual_network()
elif st_if.get_service_interface_type() == 'right':
right_vn = si_if.get_virtual_network()
if left_vn == "":
parent_str = self.obj.get_parent_fq_name_str()
left_vn = parent_str + ':' + svc_info.get_left_vn_name()
if right_vn == "":
parent_str = self.obj.get_parent_fq_name_str()
right_vn = parent_str + ':' + svc_info.get_right_vn_name()
return left_vn, right_vn
def update_autonomous_system(self, asn):
old_rt = self.route_target
old_asn = int(old_rt.split(':')[1])
if int(asn) == old_asn:
return
rtgt_num = int(old_rt.split(':')[-1])
rt_key = "target:%s:%d" % (asn, rtgt_num)
rtgt_obj = ResourceBaseST.get_obj_type_map().get(
'route_target').locate(rt_key)
try:
obj = self.read_vnc_obj(fq_name=self.name)
obj.set_route_target(rtgt_obj.obj)
self._vnc_lib.logical_router_update(obj)
except NoIdError:
self._logger.error("NoIdError while accessing logical router %s" %
self.name)
# We need to execute this code only in case of SNAT routing.
# If vxlan_routing is enabled, LR RTs will not have a back_ref
# to the Routing Instance of all the connected VNs
if not self.vxlan_routing:
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_del=[old_rt],
rt_add=[rt_key])
self.delete_route_targets([old_rt])
self.route_target = rt_key
def populate_rules(self, rule_type, refs):
rule_entries = set()
for np_sg, attr in list(refs.items()):
if attr and attr.rule:
# List of rule UUIDs is provided. Populate
# the SLO with the list alone.
np_sg_rule_list = attr.rule
else:
# No rule uuid is specified. Query for the
# network policy or security group
# and include all rules in them.
# Use the default rule rate in the SLO.
np_sg_st_obj = (ResourceBaseST.get_obj_type_map().get(
'network_policy').get(np_sg)
or ResourceBaseST.get_obj_type_map().get(
'security_group').get(np_sg))
np_sg_rule_list = getattr(np_sg_st_obj.obj,
'get_' + rule_type +
'_entries')().get_policy_rule()
for rule_entry in np_sg_rule_list:
rate_to_use = (getattr(rule_entry, 'rate', None)
or self.security_logging_object_rate)
rule_entries.add(
SecurityLoggingObjectRuleEntryType(rule_entry.rule_uuid,
rate=rate_to_use))
# end for rule_entry
# end for np_sg
return rule_entries
def delete_route_targets(route_targets=None):
for rt in route_targets or []:
try:
ResourceBaseST.get_obj_type_map().get(
'route_target').delete_vnc_obj(rt)
except RefsExistError:
pass
def set_virtual_networks(self, vn_set):
# do not add RT assigned to LR to the VN
# when vxlan_routing is enabled
if self.logical_router_type == 'vxlan-routing':
self.virtual_networks = vn_set
return
for vn in self.virtual_networks - vn_set:
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()
# error due to inconsistency in db
if ri_obj is None:
self._logger.error("Primary RI is None for VN: " +
str(vn_obj.name))
continue
rt_del = (set([self.route_target]) | self.rt_list
| self.bgpvpn_rt_list | self.bgpvpn_import_rt_list
| self.bgpvpn_export_rt_list)
ri_obj.update_route_target_list(rt_add=set(), rt_del=rt_del)
self.delete_route_targets(rt_del - set([self.route_target]))
for vn in vn_set - 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()
rt_add = (self.rt_list | set([self.route_target])
| self.bgpvpn_rt_list)
ri_obj.update_route_target_list(
rt_add=rt_add,
rt_add_import=self.bgpvpn_import_rt_list,
rt_add_export=self.bgpvpn_export_rt_list)
self.virtual_networks = vn_set
def update_service_instances(self, si_set, retain_as_path_changed=False):
old_si_set = self.service_instances
if retain_as_path_changed:
vns = list(self.virtual_networks)
left_vn = vns[0]
right_vn = vns[1]
npvn = ResourceBaseST.get_obj_type_map().get(
'virtual_network').get(left_vn)
list(npvn.service_chains.values())[0][0].created = False
npvn = ResourceBaseST.get_obj_type_map().get(
'virtual_network').get(right_vn)
list(npvn.service_chains.values())[0][0].created = False
for si_name in old_si_set - si_set:
si_list = self._service_instances.get(si_name)
if si_list:
si_list.discard(self.name)
if not si_list:
del self._service_instances[si_name]
si = ResourceBaseST.get_obj_type_map().get('service_instance').get(
si_name)
if si is None:
continue
si.network_policys.discard(self.name)
for si_name in si_set - old_si_set:
si_list = self._service_instances.setdefault(si_name, set())
si_list.add(self.name)
si = ResourceBaseST.get_obj_type_map().get('service_instance').get(
si_name)
if si is None:
continue
si.network_policys.add(self.name)
self.service_instances = si_set
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 get_virtual_machine_or_port_tuple(self):
if self.port_tuples:
pt_list = [ResourceBaseST.get_obj_type_map().get('port_tuple').get(x) for x in self.port_tuples if x is not None]
return pt_list
elif self.virtual_machine:
vm = ResourceBaseST.get_obj_type_map().get('virtual_machine').get(self.virtual_machine)
return [vm] if vm is not None else []
return []
def check_create(self):
# Check if this service chain can be created:
# - all service instances have VMs
# - all service instances have proper service mode
# - all service VMs have left and if needed, right interface
# If checks pass, return a dict containing mode and vm_list for all
# service instances so that we don't have to find them again
ret_dict = {}
for service in self.service_list:
si = ResourceBaseST.get_obj_type_map().get('service_instance').get(
service)
if si is None:
self.log_error("Service instance %s not found " % service)
return None
vm_list = si.virtual_machines
pt_list = si.port_tuples
if not vm_list and not pt_list:
self.log_error("No vms/pts found for service instance " +
service)
return None
mode = si.get_service_mode()
if mode is None:
self.log_error("service mode not found: %s" % service)
return None
vm_info_list = []
for service_vm in vm_list:
vm_obj = ResourceBaseST.get_obj_type_map().get(
'virtual_machine').get(service_vm)
if vm_obj is None:
self.log_error('virtual machine %s not found' % service_vm)
return None
vm_info = self._get_vm_pt_info(vm_obj, mode)
if vm_info:
vm_info_list.append(vm_info)
for pt in pt_list:
pt_obj = ResourceBaseST.get_obj_type_map().get(
'port_tuple').get(pt)
if pt_obj is None:
self.log_error('virtual machine %s not found' % pt)
return None
vm_info = self._get_vm_pt_info(pt_obj, mode)
if vm_info:
vm_info_list.append(vm_info)
# end for service_vm
if not vm_info_list:
return None
virtualization_type = si.get_virtualization_type()
ret_dict[service] = {
'mode': mode,
'vm_list': vm_info_list,
'virtualization_type': virtualization_type
}
return ret_dict
def evaluate(self, **kwargs):
for router in list(
ResourceBaseST.get_obj_type_map().get('bgp_router').values()):
router.update_global_asn(self._autonomous_system)
router.update_peering()
# end for router
for router in list(ResourceBaseST.get_obj_type_map().get(
'logical_router').values()):
router.update_autonomous_system(self._autonomous_system)
# end for router
if self.obj.bgpaas_parameters:
self.update_bgpaas_parameters(self.obj.bgpaas_parameters)
def delete_properties(self):
policy_name = '_internal_' + self.name
policy = ResourceBaseST.get_obj_type_map().get('network_policy').get(policy_name)
if policy is None:
return
for vn_name in policy.virtual_networks:
vn = ResourceBaseST.get_obj_type_map().get('virtual_network').get(vn_name)
if vn is None:
continue
del vn.network_policys[policy_name]
# end for vn_name
ResourceBaseST.get_obj_type_map().get('network_policy').delete(policy_name)
def update_routing_instances(self, ri_refs):
routing_instances = dict((':'.join(ref['to']), ref['attr'])
for ref in ri_refs or [])
old_ri_set = set(self.routing_instances.keys())
new_ri_set = set(routing_instances.keys())
for ri_name in old_ri_set - new_ri_set:
ri = ResourceBaseST.get_obj_type_map().get('routing_instance').get(ri_name)
if ri:
ri.virtual_machine_interfaces.discard(self.name)
for ri_name in new_ri_set - old_ri_set:
ri = ResourceBaseST.get_obj_type_map().get('routing_instance').get(ri_name)
if ri:
ri.virtual_machine_interfaces.add(self.name)
self.routing_instances = routing_instances
def get_allocated_interface_ip(self, side, version):
vm_pt_list = []
for vm_name in self.virtual_machines or []:
vm_pt_list.append(ResourceBaseST.get_obj_type_map().get('virtual_machine').get(vm_name))
for pt_name in self.port_tuples or []:
vm_pt_list.append(ResourceBaseST.get_obj_type_map().get('port_tuple').get(pt_name))
for vm_pt in vm_pt_list:
if not vm_pt:
continue
vmi = vm_pt.get_vmi_by_service_type(side)
if not vmi:
continue
return vmi.get_any_instance_ip_address(version)
return None
def set_bgpaas_clients(self):
if (self.bgpaas_shared and self.bgp_routers):
bgpr = ResourceBaseST.get_obj_type_map().get('bgp_router').get(
list(self.bgp_routers)[0])
self.bgpaas_clients[self.obj.name] = bgpr.obj.get_fq_name_str()
else:
for bgp_router in self.bgp_routers:
bgpr = ResourceBaseST.get_obj_type_map().get('bgp_router').get(
bgp_router)
if bgpr is None:
continue
for vmi in self.virtual_machine_interfaces:
if vmi.split(':')[-1] == bgpr.obj.name:
self.bgpaas_clients[vmi] = bgpr.obj.get_fq_name_str()
break
def update(self, obj=None):
changed = self.update_vnc_obj(obj)
if 'service_instance' in changed:
new_refs = dict((':'.join(ref['to']), ref['attr'].interface_type)
for ref in self.obj.get_service_instance_refs() or [])
for ref in set(self.service_instances.keys()) - set(new_refs.keys()):
si = ResourceBaseST.get_obj_type_map().get('service_instance').get(ref)
if si and self.name in si.route_aggregates:
del si.route_aggregates[self.name]
for ref in set(new_refs.keys()):
si = ResourceBaseST.get_obj_type_map().get('service_instance').get(ref)
if si:
si.route_aggregates[self.name] = new_refs[ref]
self.service_instances = new_refs
return changed
def get_vmi_by_service_type(self, service_type):
for vmi_name in self.virtual_machine_interfaces:
vmi = ResourceBaseST.get_obj_type_map().get(
'virtual_machine_interface').get(vmi_name)
if vmi and vmi.service_interface_type == service_type:
return vmi
return None
def reinit(cls):
for obj in cls.list_vnc_obj():
try:
if (obj.get_routing_instance_back_refs()
or obj.get_logical_router_back_refs()):
cls.locate(obj.get_fq_name_str(), obj)
else:
cls.delete_vnc_obj(obj.get_fq_name_str())
except Exception as e:
cls._logger.error(
"Error in reinit for %s %s: %s" %
(cls.obj_type, obj.get_fq_name_str(), str(e)))
for ri, val in cls._object_db._rt_cf.get_range():
rt = val['rtgt_num']
asn = ResourceBaseST.get_obj_type_map().get(
'global_system_config').get_autonomous_system()
rt_key = "target:%s:%s" % (asn, rt)
if rt_key not in cls:
cls._object_db.free_route_target(ri, asn)
# This is to handle upgrade scenarios.
# In case we upgrade to a release containing support to 4 Byte ASN
# Once all the RTs are recreated in ZK in their new path, delete
# the old path for RTs in ZK
cls._object_db.delete_route_target_directory(
'%s%s' % (cls._object_db._zk_path_pfx, "/id/bgp/route-targets"))
def _get_vm_pt_info(self, vm_pt, mode):
# From a ResourceBaseST.get_obj_type_map().get('virtual_machine') or ResourceBaseST.get_obj_type_map().get('port_tuple') object, create a vm_info
# dict to be used during service chain creation
vm_info = {'vm_uuid': vm_pt.uuid}
for interface_name in vm_pt.virtual_machine_interfaces:
interface = ResourceBaseST.get_obj_type_map().get('virtual_machine_interface').get(interface_name)
if not interface:
continue
if not (interface.is_left() or interface.is_right()):
continue
v4_addr = None
v6_addr = None
if mode != 'transparent':
v4_addr = interface.get_any_instance_ip_address(4)
v6_addr = interface.get_any_instance_ip_address(6)
if v4_addr is None and v6_addr is None:
self.log_error("No ip address found for interface "
+ interface_name)
return None
vmi_info = {'vmi': interface, 'v4-address': v4_addr,
'v6-address': v6_addr}
vm_info[interface.service_interface_type] = vmi_info
if 'left' not in vm_info:
self.log_error('Left interface not found for %s' %
vm_pt.name)
return None
if ('right' not in vm_info and mode != 'in-network-nat' and
self.direction == '<>'):
self.log_error('Right interface not found for %s' %
vm_pt.name)
return None
return vm_info
def delete_fabric_vmi_ref(self, fabric_vmi_st):
if fabric_vmi_st is not None:
vn_st = \
ResourceBaseST.get_obj_type_map() \
.get('virtual_network') \
.get(fabric_vmi_st.virtual_network)
if vn_st is not None:
if self.name in vn_st.virtual_port_groups:
vn_st.virtual_port_groups.remove(self.name)
fabric_vmi_uuid = fabric_vmi_st.uuid
if fabric_vmi_uuid is not None:
try:
self._vnc_lib.ref_update('virtual-port-group', self.uuid,
'virtual-machine-interface',
fabric_vmi_uuid, None, 'DELETE')
fabric_vmi = self._vnc_lib \
.virtual_machine_interface_read(
id=fabric_vmi_uuid)
fabric_vmi_vpg_back_refs = \
fabric_vmi.get_virtual_port_group_back_refs()
if fabric_vmi_vpg_back_refs is None or \
len(fabric_vmi_vpg_back_refs) == 0:
self._vnc_lib \
.virtual_machine_interface_delete(
id=fabric_vmi_uuid)
except NoIdError:
pass
except Exception as e:
msg = ("Unexpected error during "
"dereferencing fabric vmi %s: %s" %
(fabric_vmi_st.name, str(e)))
self._logger.error(msg)
self.add_ignored_error(msg)
def __init__(self, name, obj=None):
self.name = name
self.virtual_networks = set()
self.service_instances = set()
self.internal = False
self.rules = []
self.has_subnet_only_rules = True
self.security_logging_objects = set()
# policies referred in this policy as src or dst
self.referred_policies = set()
self.retain_as_path_rules = set()
# policies referring to this policy as src or dst
self.update(obj)
for vn_ref in self.obj.get_virtual_network_back_refs() or []:
vn_name = ':'.join(vn_ref['to'])
self.virtual_networks.add(vn_name)
vn = ResourceBaseST.get_obj_type_map().get('virtual_network').get(
vn_name)
if vn is None:
continue
vnp = VirtualNetworkPolicyType(**vn_ref['attr'])
vn.add_policy(name, vnp)
self.network_policys = NetworkPolicyST._network_policys.get(
name, set())
self.update_multiple_refs('security_logging_object', self.obj)
def add_properties(self, props):
left_vn_str, right_vn_str = self.get_virtual_networks(props)
ret = (self.auto_policy == props.auto_policy)
if (left_vn_str, right_vn_str) != (self.left_vn_str,
self.right_vn_str):
self.left_vn_str = left_vn_str
self.right_vn_str = right_vn_str
ret = True
if not props.auto_policy:
self.delete_properties()
return ret
self.auto_policy = True
if (not self.left_vn_str or not self.right_vn_str):
self._logger.error(
"%s: route table next hop service instance must "
"have left and right virtual networks" % self.name)
self.delete_properties()
return ret
policy_name = "_internal_" + self.name
addr1 = AddressType(virtual_network=self.left_vn_str)
addr2 = AddressType(virtual_network=self.right_vn_str)
action_list = ActionListType(apply_service=[self.name])
prule = PolicyRuleType(direction="<>",
protocol="any",
src_addresses=[addr1],
dst_addresses=[addr2],
src_ports=[PortType()],
dst_ports=[PortType()],
action_list=action_list)
pentry = PolicyEntriesType([prule])
policy_obj = NetworkPolicy(policy_name, network_policy_entries=pentry)
policy = ResourceBaseST.get_obj_type_map().get(
'network_policy').locate(policy_name, policy_obj)
policy.virtual_networks = set([self.left_vn_str, self.right_vn_str])
policy.set_internal()
vn1 = ResourceBaseST.get_obj_type_map().get('virtual_network').get(
self.left_vn_str)
if vn1:
vn1.add_policy(policy_name)
vn2 = ResourceBaseST.get_obj_type_map().get('virtual_network').get(
self.right_vn_str)
if vn2:
vn2.add_policy(policy_name)
def update_route_target_list(self,
rt_add=None,
rt_add_import=None,
rt_add_export=None,
rt_del=None):
update = False
for rt in rt_del or []:
if rt in self.stale_route_targets:
self.stale_route_targets.remove(rt)
rtgt_obj = RouteTarget(rt)
self.obj.del_route_target(rtgt_obj)
update = True
for rt in rt_add or []:
if rt not in self.stale_route_targets:
rtgt_obj = ResourceBaseST.get_obj_type_map().get(
'route_target').locate(rt).obj
inst_tgt_data = InstanceTargetType(import_export=None)
self.obj.add_route_target(rtgt_obj, inst_tgt_data)
update = True
else:
self.stale_route_targets.remove(rt)
for rt in rt_add_import or []:
if rt not in self.stale_route_targets:
rtgt_obj = ResourceBaseST.get_obj_type_map().get(
'route_target').locate(rt).obj
inst_tgt_data = InstanceTargetType(import_export='import')
self.obj.add_route_target(rtgt_obj, inst_tgt_data)
update = True
else:
self.stale_route_targets.remove(rt)
for rt in rt_add_export or []:
if rt not in self.stale_route_targets:
rtgt_obj = ResourceBaseST.get_obj_type_map().get(
'route_target').locate(rt).obj
inst_tgt_data = InstanceTargetType(import_export='export')
self.obj.add_route_target(rtgt_obj, inst_tgt_data)
update = True
else:
self.stale_route_targets.remove(rt)
if update:
try:
self._vnc_lib.routing_instance_update(self.obj)
# update local cache of ri-->rt refs
self.update_route_targets()
except NoIdError:
return
def delete_obj(self):
for fabric_vmi_st_name in self.virtual_machine_interfaces:
fabric_vmi_st = \
ResourceBaseST.get_obj_type_map() \
.get('virtual_machine_interface') \
.get(fabric_vmi_st_name)
self.delete_fabric_vmi_ref(fabric_vmi_st)
self.delete_physical_interface_ref()
def get_primary_instance_ip_address(self, ip_version=4):
for ip_name in self.instance_ips:
ip = ResourceBaseST.get_obj_type_map().get('instance_ip').get(
ip_name)
if ip.is_primary() and ip.instance_ip_address and \
ip_version == ip.ip_version:
return ip.instance_ip_address
return None
def update(self, obj=None):
changed = self.update_vnc_obj(obj)
if 'bgp_router' in changed:
bgp_rtr = ResourceBaseST.get_obj_type_map().get(
'bgp_router').locate(self.bgp_router)
if bgp_rtr:
bgp_rtr.physical_router = self.name
bgp_rtr.physical_router_changed = True
return changed
def __init__(self, name, obj=None):
self.name = name
self.obj = obj or self.read_vnc_obj(fq_name=name)
self.stale_route_targets = []
self.service_chain = self._get_service_id_from_ri(self.name)
self.connections = set()
self.virtual_network = None
self.is_default = self.obj.get_routing_instance_is_default()
self.add_to_parent(self.obj)
self.route_target = None
self.routing_policys = {}
self.route_aggregates = set()
self.route_targets = set()
self.service_chain_info = self.obj.get_service_chain_information()
self.v6_service_chain_info = \
self.obj.get_ipv6_service_chain_information()
if self.obj.get_fq_name() in (common.IP_FABRIC_RI_FQ_NAME,
common.LINK_LOCAL_RI_FQ_NAME):
return
self.locate_route_target()
for ri_ref in self.obj.get_routing_instance_refs() or []:
conn_fq_name = ':'.join(ri_ref['to'])
if conn_fq_name != 'ERROR':
self.connections.add(conn_fq_name)
else:
self._logger.debug("Invalid connection detected in RI " + name)
# Remove the connection ref in the API server as well.
try:
self._vnc_lib.ref_update('routing-instance', self.obj.uuid,
'routing-instance',
ri_ref['uuid'], None, 'DELETE')
except NoIdError as e:
self._logger.debug("Ref not found in DB for RI " + name)
self._logger.debug(e)
if self.is_default:
vn = ResourceBaseST.get_obj_type_map().get('virtual_network').get(
self.virtual_network)
if vn is None:
return
for network in vn.expand_connections():
vn.add_ri_connection(network, self)
# if primary RI is connected to another primary RI, we need to
# also create connection between the VNs
for connection in self.connections:
remote_ri_fq_name = connection.split(':')
if remote_ri_fq_name[-1] == remote_ri_fq_name[-2]:
vn.connections.add(':'.join(remote_ri_fq_name[0:-1]))
vmi_refs = self.obj.get_virtual_machine_interface_back_refs() or []
self.virtual_machine_interfaces = set(
[':'.join(ref['to']) for ref in vmi_refs])
self.update_multiple_refs('route_aggregate', self.obj)
for ref in self.obj.get_routing_policy_back_refs() or []:
rp_name = ':'.join(ref['to'])
self.routing_policys[rp_name] = ref['attr']['sequence']
if self.is_default:
self.update_static_routes()
def delete_obj(self):
self.add_rules(None)
self._internal_policies.discard(self.name)
for vn_name in self.virtual_networks:
vn = ResourceBaseST.get_obj_type_map().get('virtual_network').get(vn_name)
if vn is None:
continue
if self.name in vn.network_policys:
del vn.network_policys[self.name]
def delete_obj(self):
self.update_multiple_refs('virtual_machine_interface', {})
self.update_multiple_refs('route_table', {})
self.update_multiple_refs('bgpvpn', {})
self.update_virtual_networks()
self.delete_route_targets([self.route_target])
asn = ResourceBaseST.get_obj_type_map().get(
'global_system_config').get_autonomous_system()
self._object_db.free_route_target(self.name, asn)
