def get_edge_list_by_node(self, edge_type, node): """ Get the edges connected with specified node in a given direction If the input edge_type is DIRECTED then graph is asymmetric If the edge_type is UNDIRECTED then graph is symmetric @param edge_type: The direction of the edge @type edge_type : L{Enum<onep.topology.Enum>} @param node: The node of interest. The Node object must contain the node name @type node: L{Node<onep.topology.Node>} @return: A list of Edges. If no match found empty list is returned @rtype: C{list} of L{Edge<onep.topology.Edge>} """ validate(node, Node) if not isValidEnum(Edge.EdgeType, edge_type): raise OnepIllegalArgumentException('edge_type is invalid') edge_list = [] for edge in self._edge_map.values(): if node.name == edge._head_node.name and node.address_list is not None and edge._head_node.address_list is not None and set(node.address_list) == set(edge._head_node.address_list): edge_list.append(edge) if node.name == edge._tail_node.name and node.address_list is not None and edge._tail_node.address_list is not None and set(node.address_list) == set(edge._tail_node.address_list): edge_list.append(edge) if edge_type == Edge.EdgeType.DIRECTED: return edge_list else: return self._convert_to_undirected_edge_list(edge_list)
def _from_idl(attr_idl, network_element): """For internal use only""" if attr_idl == None: return attr = None attrName = None if not network_element.is_connected(): log.debug('Application is not connected to network element ' + network_element.host_address) return if network_element.session_handle == None: log.debug('Application is not connected to network element ' + network_element.host_address) return format = attr_idl.format attr_type = attr_idl.type if not isValidEnum(OnepAAAAttributeType, attr_type): raise OnepException('Error in attr type ' + str(attr_type)) if attr_idl.type == OnepAAAAttributeType.ONEP_AAA_AT_APP_ATTR: app_attr_value = attr_idl.str_value if app_attr_value.startswith('"') and app_attr_value.endswith('"'): app_attr_value = app_attr_value.substring[1:-1] app_value = app_attr_value.split(':') if len(app_value) < 3: raise OnepException('Invalid app attribute format ' + str(app_value)) attrName = app_value[0] try: if app_value[1].lower() == 'string': attr = StringAttribute(attr_type, attrName, app_value[2]) else: attr = IntAttribute(attr_type, attrName, int(app_value[2])) except OnepIllegalArgumentException as e: raise OnepException( 'Error adding a Application attribute type ' + str(app_value), e) else: result = { AttrFormat_e.AAA_TYPE_FORMAT_ULONG: lambda _type, _idl: IntAttribute(_type, None, _idl.ulong_value), AttrFormat_e.AAA_TYPE_FORMAT_STRING: lambda _type, _idl: StringAttribute(_type, None, _idl.str_value), AttrFormat_e.AAA_TYPE_FORMAT_BINARY: lambda _type, _idl: BinaryAttribute(_type, None, _idl.binary_value ), AttrFormat_e.AAA_TYPE_FORMAT_IP_ADDR: lambda _type, _idl: BinaryAttribute(_type, None, _idl.binary_value ), AttrFormat_e.AAA_TYPE_FORMAT_IPV6_ADDR: lambda _type, _idl: BinaryAttribute(_type, None, _idl.binary_value) } attr = result[format](attr_type, attr_idl) if attr == None: raise OnepException('Unsupported Attribute Format') return attr
def __init__(self, name, type, address_list): """ @raise OnepIllegalArgumentException: The exception is thrown when address received in the address list is None or invalid. """ validate(name, str) if isValidEnum(self.NodeType, type) is False: raise OnepIllegalArgumentException('type is invalid.') validate(address_list, list) for addr in address_list: validate(addr, str) self._name = name self._type = type self._address_list = address_list self.mt_node = None
def __init__(self, name, type, node, address_list): """ Constructor For internal use only @raise OnepIllegalArgumentException: The exception is thrown if any of the input argument is invalid. """ validate(name, str) if isValidEnum(self.NodeConnectorType, type) is False: raise OnepIllegalArgumentException('type is invalid.') if not isinstance(node, Node): raise OnepIllegalArgumentException('node is invalid.') validate(address_list, list) for addr in address_list: validate(addr, str) self._node = node self._name = name self._type = type self._address_list = address_list
def get_edge_list(self, edge_type): """ Get the list of edges based on the directionality in a grpah The method returns a set of edges based on the direction requested if DIRECTED edges are requested then the edges to/from Node A and Node B are treated as different edges and both edges are returned. If UNDIRECTED edges are requested then the graph is assumed symmetric and only one edge in this case is returned @param edge_type: Type of edge either DIRECTED or UNDIRECTED. If the input is None, default type DIRECTED will be used @type edge_type: C{list} of L{Edge<onep.topology.Edge>} """ if not isValidEnum(Edge.EdgeType, edge_type): raise OnepIllegalArgumentException('edge_type is invalid') if edge_type == None or edge_type == Edge.EdgeType.DIRECTED: return self._edge_map.values() else: return self._convert_to_undirected_edge_list(self._edge_map.values())
def __init__(self, start_prefix, range_type, count): """ Create the range tuple (Start L3 Unicast Prefix, Range Type, Count) used for filtering. If range type is EQUAL_OR_LARGER, then the range indicates Count routes starting with the prefix equal or lexically larger than Start Prefix. If range type is ROUTING_ROUTE_RANGE_LARGER, then the filter indicates Count routes starting with the prefix lexically larger than Start Prefix. If count is 0, it is treated as no count limit and all routes matching the (Start L3 Unicast Prefix, Range Type) are included. @param start_prefix: The starting prefix reference of the range. @type start_prefix: L{NetworkPrefix<onep.interfaces.NetworkPrefix>} @param range_type: Indicate if the range include the start prefix. @type range_type: L{RouteRange.RangeType<onep.routing.RouteRange>} @param count: Maximum number of route the range should cover. A count of 0 means no limit. @type count: C{int} """ super(L3UnicastRouteRange, self).__init__() if not isinstance(start_prefix, NetworkPrefix): raise OnepIllegalArgumentException('start_prefix', 'Invalid type') if not isValidEnum(RouteRange.RangeType, range_type): raise OnepIllegalArgumentException('range_type', 'Invalid type') if count < 0 or not isinstance(count, int): raise OnepIllegalArgumentException('count', 'Invalid type') self._start_prefix = start_prefix self._range_type = range_type self._count = count
def _set_range_type(self, range_type): if not isValidEnum(RouteRange.RangeType, range_type): raise OnepIllegalArgumentException('range_type', 'Invalid type') self._range_type = range_type
def update(self, event_type, list): """ Updates the topology graph object with a list of objects passed, based on the topology change events. If the event is: ONEP_TOPOLOGY_EDGES_ADD - The list should contain a set of EDGE object that needs to be added to the graph object. ONEP_TOPOLOGY_EDGES_DELETE - The list should contain a set of EDGE objects that needs to be removed from the graph object. ONEP_TOPOLOGY_NODES_ADD - The list should contain a set of nodes that needs to be added to the graph object. ONEP_TOPOLOGY_NODES_DELETE - The list should contain a set of nodes that needs to be remove to the graph object. Removing a node from a graph would also result in removing all IN bound and OUT bound edges associated with the node. Note: Adding a node to a graph would only reflect in the output of get_node_list() method, and the node remains orphaned. @param event_type: Type of topology change event. @type event_type: L{enum<onep.core.util.Enum>} @param list: List of edges or nodes that needs to be updated based on @type list: C{list} @raise OnepIllegalArgumentException: The exception is thrown when the input list contains wrong type of element. """ from onep.topology.TopologyEvent import TopologyEvent if isValidEnum(TopologyEvent.TopologyEventType, event_type) is False: raise OnepIllegalArgumentException('event_type is invalid.') return validate(list, type([])) if event_type == TopologyEvent.TopologyEventType.EDGES_ADD: for obj in list: if not isinstance(obj, Edge): raise OnepIllegalArgumentException('Edge is invalid.') with self._lock: self._edge_map[str(obj)] = obj self._add_to_index(obj) return if event_type == TopologyEvent.TopologyEventType.EDGES_DELETE: for obj in list: if not isinstance(obj, Edge): raise OnepIllegalArgumentException('Edge is invalid.') with self._lock: if self._edge_map.has_key(str(obj)): self._log.debug('update1 removing edge ' + str(obj)) del self._edge_map[str(obj)] self._remove_from_index(obj) else: edge_to_remove = self._get_matching_edge_from_map(obj) if edge_to_remove: self._log.debug('update2 removing edge ' + str(edge_to_remove)) del self._edge_map[str(edge_to_remove)] self._remove_from_index(edge_to_remove) return if event_type == TopologyEvent.TopologyEventType.NODES_ADD: for obj in list: if not isinstance(obj, Node): raise OnepIllegalArgumentException('Node is invalid.') with self._lock: self._node_map[str(obj)] = obj return if event_type == TopologyEvent.TopologyEventType.NODES_DELETE: for obj in list: if not isinstance(obj, Node): raise OnepIllegalArgumentException('Node is invalid.') edge_list = self.get_edge_list_by_node(Edge.EdgeType.DIRECTED, obj) for edge in edge_list: with self._lock: if self._edge_map.has_key(str(edge)): self._log.debug('update ND removing edge ' + str(edge)) del self._edge_map[str(edge)] self._remove_from_index(edge) break else: edge_to_remove = self._get_matching_edge_from_map(edge) if edge_to_remove: self._log.debug('update ND2 removing edge ' + str(edge_in_map)) del self._edge_map[str(edge_in_map)] self._remove_from_index(edge_in_map) break with self._lock: if self._node_map.has_key(str(obj)): self._log.debug('update2 removing node ' + str(obj)) del self._node_map[str(obj)] return