Ejemplo n.º 1
0
def getAllRings(graph, isMultigraph):
	""" Parameters: graph -> networkx graph or multigraph object,
		isMultigraph -> True if graph is multigraph else false
		Returns list of list of edges forming cycles in the graph.
	"""		
	if isMultigraph:
		multigraph, graph = graph, nx.Graph(graph)				
	all_cycle_edge_list = []
	Debuglogger.info("Getting cycle basis")
	cycle_basis_list = getCycleBasis(graph)								# get cycle basis of given graph
	
	Userlogger.info('\nGetting all the rings from physical topology')
	for i in range(1,len(cycle_basis_list)+1):							# form combinations of cycle basis
		Debuglogger.debug("Getting combinations of basis cycle picking "+str(i)+" items")
		for combination in combinations(cycle_basis_list,i):
			if combination:
				Debuglogger.debug("combination exists")
				edge_set = {}
				for basis in combination:								# find symmetric difference of
					edge_set = set(basis).symmetric_difference(edge_set)# members of each combination	
				ring = nx.Graph()
				ring.add_edges_from(list(edge_set))		
				if isCycle(ring):										#if the member is a connected cycle
					Debuglogger.debug("Is a connected cycle")
					all_cycle_edge_list.append(list(edge_set))			# add to list of all cycles
					Debuglogger.info("Ring "+str(len(all_cycle_edge_list))+" "+str(all_cycle_edge_list[-1]))
					Userlogger.info("Ring "+str(len(all_cycle_edge_list))+" "+str(all_cycle_edge_list[-1]))
	if isMultigraph:
		return getRingsMultigraph(multigraph, all_cycle_edge_list)
	return all_cycle_edge_list
Ejemplo n.º 2
0
        def drawTopology(topology,isMultigraph,saveas):
        	""" drawTopology() method takes networkx object of the network, filename of the image to create and creates image of the network 
        	    with a given filename. """ 
        	
        	Debuglogger.info("Drawing graph with a given networkxobject")#
		G = pydot.Dot(graph_type='graph', dpi=300 , splines = "curved")
		G.set_node_defaults(style="filled", fillcolor="grey",fontsize=7.0)
		G.set_layout("circo")
		G.set_edge_defaults(fontsize=7.0)
		
		for edge in list(set(topology.edges())):
			node1=edge[0]
			node2=edge[1]
			if isMultigraph:
				for ed_info in topology[node1][node2]:
					if topology[node1][node2][ed_info]['link_type']=='Gig':	
						edge_style = 'bold'
					elif topology[node1][node2][ed_info]['link_type'] == 'Fas':
						edge_style = 'dotted'
					G.add_edge(pydot.Edge(node1,node2,style=edge_style,label=topology[node1][node2][ed_info]['wt']))           
			else:
					#print saveas
					if topology[node1][node2]['link_type']=='Gig':	
						edge_style = 'bold'
					elif topology[node1][node2]['link_type'] == 'Fas':
						edge_style = 'dotted'
					G.add_edge(pydot.Edge(node1,node2,style=edge_style,label=topology[node1][node2]['wt']))
		G.write_png(saveas)
Ejemplo n.º 3
0
	def makeGraph(edges_info):
		""" makeGraph() method takes edges_info as input and returns a networkx object of the network. edges_info is a list with entries being the edges in the 		    network. Edges are entered as two switchname+IPs+Ports and corresponding intefaces and type of link. """
		
		Debuglogger.info("Making a graph object with a given Edge list")	
		
		graph = nx.Graph()			
		multigraph = nx.MultiGraph()
		for edge in edges_info:
			info = edge.split(' ')
			node1 = info[0]
			node2 = info[1]
			port = " ".join(info[2:-1])
			link_type = info[-1]
			if node1 not in graph:
				graph.add_node(node1,node_port=[])
				multigraph.add_node(node1,node_port=[])
			graph.node[node1]['node_port'].append(info[2])
			multigraph.node[node1]['node_port'].append(info[2])
			
			if node2 not in graph:
				graph.add_node(node2,node_port=[])
				multigraph.add_node(node2,node_port=[])	
			graph.node[node2]['node_port'].append(info[3])
			multigraph.node[node2]['node_port'].append(info[3])
			
			multigraph.add_edge(node1,node2, wt=port, link_type=link_type)
			graph.add_edge(node1,node2, wt=port, link_type=link_type)
			
		if len(multigraph.edges())>len(graph.edges()):
			return multigraph,True
		return graph,False
Ejemplo n.º 4
0
	def eList_Modify():
		""" eList_Modify() modifies the EdgeList such as that instead of switchname it replaces the switchname with switchname+IP+Port. """
	
		Debuglogger.info("Modifying the Edge List in Network")#
		
		for switch_info in Network_topology.SwitchList.keys():
			switch_name= switch_info.split('\n')[0]						
			for i in range(0,len(Network_topology.EdgeList)):
				Network_topology.EdgeList[i]=Network_topology.EdgeList[i].replace(switch_name,switch_info)
Ejemplo n.º 5
0
def isCycle(graph):
	"""	This function takes a networkx graph object as input and returns True if the graph is a cycle
		Note: A graph is a cycle iff degree of every node is two and the graph is connected.
	"""
	if graph:
		degree_hist = nx.degree_histogram(graph) 			# get frequency of degree of all nodes
		if degree_hist[2] == len(graph.nodes()) and nx.is_connected(graph):	# if all nodes have degree = 2 => cycle
			Debuglogger.debug("Is a cycle")
			return True
	Debuglogger.debug("Is not a cycle")
	return False	
Ejemplo n.º 6
0
	def findname(self):							
		""" findname() finds the name of switch from cdp data. """
		
		Debuglogger.info("Finding name through cdp data")
		fout=open('tempLog.txt','r')
		lines=fout.readlines()
		for line in lines:
			if '>' in line:
				break
		self.SwitchName=line[0:line.index('>')]
		fout.close()
Ejemplo n.º 7
0
def getCycleBasis(graph):
	"""	Input: networkx simple graph
		Returns list of graph objects that form cycle basis of the input graph
	"""
	Debuglogger.info("In getCycleBasis")
	cycle_basis_list = [] 								# list of list of edges of each cycle basis 
	for cycle in nx.cycle_basis(graph):
		Debuglogger.debug("cycle basis ->"+str(cycle))
		cycle_graph = nx.Graph()
		cycle_graph.add_cycle(cycle)
		cycle_basis_list.append(cycle_graph.edges())
	return cycle_basis_list
Ejemplo n.º 8
0
        def cdpread(self):
		""" cdpread() method runs cdp command through commandExecute() defined in RunCommands module  to find the neighbours. It calls findname() 
		    and addedge() to find the name of switch and finding edges corresponding to that switch. """

		Debuglogger.info("In network topology")		
			
		run.Switch_commands.commandExecute(self.host,self.port,'exec','show cdp ne')				
		self.findname()   
		Userlogger.info('\nLogged into : '+self.SwitchName+' '+self.host+' '+self.port)
		Userlogger.info(self.SwitchName+'is connected to :')							
		Network_topology.SwitchList[self.SwitchName+'\n'+self.host+'\n'+self.port]=[]			
		self.addedge()	
		Userlogger.info('\n')
Ejemplo n.º 9
0
def switch_exec(ip,port):
		""" makes the switch in exec mode instead of config mode. """			
		Debuglogger.info("In switch_exec function")
		Debuglogger.info("makes switch ("+ip+' '+port+") in exec mode")
		Userlogger.info("makes switch ("+ip+' '+port+") in exec mode")
		
		child= pexpect.spawn('telnet '+ip+' '+port)	 
		child.expect('Escape.*')
		child.sendcontrol('m')
		child.expect('#')
		child.sendline('end')				
		child.expect('#')				
		child.sendline('quit')
		child.expect(' ')				
		child.sendcontrol('m')
		child.expect('>')
Ejemplo n.º 10
0
	def showrepp(graph):
		" shows the rep topology"
		node=graph.nodes()[0]
		node_data=node.split('\n')
		Debuglogger.info('\nin show repp function')
		Userlogger.info('\nshowing the rep configuration')						
		while 1:		
			try:
				run.Switch_commands.commandExecute(node_data[1],node_data[2],'exec','show rep topology')
				templog=open('tempLog.txt','r')
				lines=templog.readlines()
				i=5
				while i<len(lines):
					print lines[i]
					i+=1
				templog.close()
				break	
			except:
				pass
Ejemplo n.º 11
0
def clearline(ip,port):
		
	""" clear the line of the given switch with ip and port """ 
	Debuglogger.info("In Clearline function")
	Debuglogger.info("Clear the line of switch with  "+ip+' '+port)
	Userlogger.info("Clear the line of switch with  "+ip+' '+port)
		
	child= pexpect.spawn('telnet '+ip)				        
	child.expect('Password:'******'lab')
	child.expect('>')
	child.sendline('en')
	child.expect('Password:'******'lab')
	child.expect('#')
	child.sendline('clear line '+str(int(port)%100))
	child.sendcontrol('m')	
	child.expect('#')	
	child.close()
	print "line is cleared"
Ejemplo n.º 12
0
	def addedge(self):
		""" addedge() finds the edge from the cdp data and calls eList() to add the edge entry (two switch name and corresponding interfaces and type of link) 			    in EdgeList. """
	
		Debuglogger.info("Finding Edges")
		
		fCDP=open('tempLog.txt','r')
		lines=fCDP.readlines()	
		i=0
		#to get to that line which has switch information
		for line in lines:
			if "Device ID" in lines[i]:
				i+=1
				break
			i+=1
		
		while i< len(lines):
			currentline_info=lines[i].split()		
			Ln=len(currentline_info)			
			if Ln==0:
				break
			
			#this is to include if switch name is too long	then it interface information comes to next line
			elif Ln==1:
				i=i+1
				nextline_info=lines[i].split()
				destSwitch=currentline_info[0]
				source_interface=nextline_info[0]+nextline_info[1]				
				dest_interface=nextline_info[-2]+nextline_info[-1]
				i=i+1	
			else:
				destSwitch=currentline_info[0]
				source_interface=currentline_info[1]+currentline_info[2]				
				dest_interface=currentline_info[-2]+currentline_info[-1]	
				i=i+1		

			Network_topology.SwitchList[self.SwitchName+'\n'+self.host+'\n'+self.port].append(source_interface+' '+dest_interface)
			self.eList(destSwitch, source_interface, dest_interface)
			
			Userlogger.info(destSwitch)
		fCDP.close()
Ejemplo n.º 13
0
def formatCycleEdgeList(graph, isMultigraph, all_cycle_edge_list_tuple, SwitchList):
	"""	Input -> graph object, bool whether multigraph or not, list of list of edges forming a cycle, dictionary port-port mappin gfor each node
		Returns list of list of edges forming cycle with attribute information
	"""
	Debuglogger.info("In formatCycleEdgeList - isMultigraph: "+str(isMultigraph))
	all_cycle_edge_list_str = []
	for ring in all_cycle_edge_list_tuple:
		cycle_str = []
		for edge in ring:
			node1 = edge[0]
			node2 = edge[1]
			if not isMultigraph:
				edge_dict = graph[node1][node2]
			else:
				edge_dict = graph[node1][node2][edge[-1]]	
			if edge_dict['wt'] in SwitchList[node1]:
				edge = (node1, node2, edge_dict['wt'], edge_dict['link_type'])
			else: edge = (node2, node1, edge_dict['wt'], edge_dict['link_type'])
			edge = " ".join(edge)
			#Debuglogger.debug(edge)
			cycle_str.append(edge)
		Debuglogger.debug(cycle_str)
		all_cycle_edge_list_str.append(cycle_str)
	return all_cycle_edge_list_str
Ejemplo n.º 14
0
def getRingsMultigraph(multigraph, all_cycle_edge_list):
	""" Input -> multigraph object, list of cycles or rings got from simple graph
		Returns list of list of edges of a ring. Edge is represented as (node1.node2,edge_id)	
	"""
	Debuglogger.info("In getRingsMultigraph")
	all_cycle_edge_list_multi = []
	for ring in all_cycle_edge_list:
		Debuglogger.debug("Ring:"+str(ring))
		cycle = []
		multi_edge_list = []
		edge_index = []
		for edge in ring:
			Debuglogger.debug("Edge:"+str(edge))
			node1 = edge[0]
			node2 = edge[1]
			if len(multigraph[node1][node2])>1:
				Debuglogger.info("this ia a multi edge")
				single_multi_edge = []
				for edge_id in multigraph[node1][node2].keys():
					single_multi_edge.append((node1, node2, edge_id))
				edge_new = single_multi_edge[0]
				multi_edge_list.append(single_multi_edge)
				edge_index.append(ring.index(edge))
			else:
				edge_new = edge + (0,)
			cycle.append(edge_new)
		all_cycle_edge_list_multi.append(cycle)
		Debuglogger.debug("multi_edge_list:"+str(multi_edge_list))
		if multi_edge_list:
			for combination in product(*multi_edge_list):
				for i in range(len(combination)):
					idx = edge_index[i]
					temp = cycle[:idx]+[combination[i]]
					if i<len(cycle):
						temp+=cycle[idx+1:]
					cycle = temp
					#print cycle
				if temp not in all_cycle_edge_list_multi:
					all_cycle_edge_list_multi.append(temp)
					Userlogger.info("Ring "+str(len(all_cycle_edge_list_multi))+" "+str(temp))
					Debuglogger.info("Ring "+str(len(all_cycle_edge_list_multi))+" "+str(temp))									
	return all_cycle_edge_list_multi