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 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 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 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 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 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 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 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 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 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_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 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 __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 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 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 __init__(self, name, obj=None): self.name = name self.virtual_machines = set() self.service_template = None self.auto_policy = False self.left_vn_str = None self.right_vn_str = None self.routing_policys = {} self.port_tuples = set() self.route_aggregates = {} self.update(obj) self.network_policys = ResourceBaseST.get_obj_type_map().get('network_policy').get_by_service_instance(self.name) self.route_tables = ResourceBaseST.get_obj_type_map().get('route_table').get_by_service_instance(self.name) for ref in self.obj.get_routing_policy_back_refs() or []: self.routing_policys[':'.join(ref['to'])] = ref['attr'] for ref in self.obj.get_route_aggregate_back_refs() or []: self.route_aggregates[':'.join(ref['to'])] = ref['attr']['interface_type'] self.set_children('port_tuple', self.obj)
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.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)
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]