4128844271

Build Type

github

Committed by GitHub

Commit Message

Merge 19e3eee2e into 2679f11b9

Pull Request Pull Request #98: Refactor connection breakdown logic

Run Details

188 of 276 branches covered (68.12%)

Branch coverage included in aggregate %.

30 of 33 new or added lines in 2 files covered. (90.91%)

26 existing lines in 3 files now uncovered.

716 of 899 relevant lines covered (79.64%)

2.39 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.86

/src/sdx/pce/topology/temanager.py

import networkx as nx
from networkx.algorithms import approximation as approx

from sdx.datamodel.parsing.connectionhandler import ConnectionHandler
from sdx.pce.topology.manager import TopologyManager
from sdx.pce.models import ConnectionRequest, TrafficMatrix


class TEManager:

    """
    TE Manager for connection - topology operations.

    Functions of this class are:

        - generate inputs to the PCE solver

        - converter the solver output.
    """

    def __init__(self, topology_data, connection_data):
        super().__init__()

        self.topology_manager = TopologyManager()
        self.connection_handler = ConnectionHandler()

        self.topology_manager.topology = (
            self.topology_manager.get_handler().import_topology_data(topology_data)
        )
        self.connection = self.connection_handler.import_connection_data(
            connection_data
        )

        self.graph = self.generate_graph_te()

    def add_topology(self, topology_data: dict):
        """
        Add a new topology to TEManager.

        :param topology_data: a dictionary that represents a topology.
        """
        self.topology_manager.add_topology(topology_data)

    def generate_connection_te(self) -> TrafficMatrix:
        """
        Generate a Traffic Matrix from the connection request we have.
        """
        ingress_port = self.connection.ingress_port
        ingress_node = self.topology_manager.topology.get_node_by_port(ingress_port.id)
        egress_port = self.connection.egress_port
        egress_node = self.topology_manager.topology.get_node_by_port(egress_port.id)

        ingress_nodes = [
            x for x, y in self.graph.nodes(data=True) if y["id"] == ingress_node.id
        ]
        
        egress_nodes = [
            x for x, y in self.graph.nodes(data=True) if y["id"] == egress_node.id
        ]

        if len(ingress_nodes) <= 0:
            raise Exception("No ingress nodes found in the graph")

        if len(egress_nodes) <= 0:
            raise Exception("No egress nodes found in the graph")

        required_bandwidth = self.connection.bandwidth
        required_latency = self.connection.latency

        request = ConnectionRequest(
            source = ingress_nodes[0],
            destination = egress_nodes[0],
            required_bandwidth = required_bandwidth,
            required_latency = required_latency
        )
        
        return TrafficMatrix(connection_requests=[request])

    def generate_graph_te(self) -> nx.Graph:
        """
        Return the topology graph that we have.
        """
        graph = self.topology_manager.generate_graph()
        graph = nx.convert_node_labels_to_integers(graph, label_attribute="id")

        # TODO: why is this needed?
        self.graph = graph
        # print(list(graph.nodes(data=True)))

        return graph

    def graph_node_connectivity(self, source=None, dest=None):
        conn = approx.node_connectivity(self.graph, source, dest)
        return conn

    def requests_connectivity(self, requests):
        for request in requests:
            conn = self.graph_node_connectivity(request[0], request[1])
            print(
                "Request Connectivity: {}, {} = {}".format(
                    request[0],
                    request[1],
                    conn,
                )
            )
        return True

    def generate_connection_breakdown(self, connection):
        assert connection is not None

        breakdown = {}
        paths = connection[0]  # p2p for now
        # cost = connection[1]
        i_port = None
        e_port = None

        print(f"Domain breakdown with graph: {self.graph}")
        print(f"Graph nodes: {self.graph.nodes}")
        print(f"Graph edges: {self.graph.edges}")

        print(f"Paths: {paths}")

        for i, j in paths.items():
            print(f"i: {i}, j: {j}")
            current_link_set = []
            for count, link in enumerate(j):
                print(f"count: {count}, link: {link}")
                assert len(link) == 2

                node_1 = self.graph.nodes.get(link[0])
                assert node_1 is not None

                node_2 = self.graph.nodes.get(link[1])
                assert node_2 is not None

                print(f"node_1: {node_1}, node_2: {node_2}")

                domain_1 = self.topology_manager.get_domain_name(node_1["id"])
                domain_2 = self.topology_manager.get_domain_name(node_2["id"])

                # # TODO: handle the cases where a domain was not found.
                # if domain_1 is None:
                #     domain_1 = f"domain_{i}"
                # if domain_2 is None:
                #     domain_2 = f"domain_{i}"

                print(f"domain_1: {domain_1}, domain_2: {domain_2}")

                current_link_set.append(link)
                current_domain = domain_1
                if domain_1 == domain_2:
                    # current_domain = domain_1
                    if count == len(j) - 1:
                        breakdown[current_domain] = current_link_set.copy()
                else:
                    breakdown[current_domain] = current_link_set.copy()
                    current_domain = None
                    current_link_set = []

        print(f"[intermediate] breakdown: {breakdown}")

        # now starting with the ingress_port
        first = True
        i = 0
        domain_breakdown = {}

        for domain, links in breakdown.items():
            print(f"Creating domain_breakdown: domain: {domain}, links: {links}")
            segment = {}
            if first:
                first = False
                last_link = links[-1]
                n1 = self.graph.nodes[last_link[0]]["id"]
                n2 = self.graph.nodes[last_link[1]]["id"]
                n1, p1, n2, p2 = self.topology_manager.topology.get_port_by_link(n1, n2)
                i_port = self.connection.ingress_port.to_dict()
                e_port = p1
                next_i = p2
            elif i == len(breakdown) - 1:
                i_port = next_i
                e_port = self.connection.egress_port.to_dict()
            else:
                last_link = links[-1]
                n1 = self.graph.nodes[last_link[0]]["id"]
                n2 = self.graph.nodes[last_link[1]]["id"]
                n1, p1, n2, p2 = self.topology_manager.topology.get_port_by_link(n1, n2)
                i_port = next_i
                e_port = p1
                next_i = p2
            segment["ingress_port"] = i_port
            segment["egress_port"] = e_port
            domain_breakdown[domain] = segment.copy()
            i = i + 1

        print(f"generate_connection_breakdown(): domain_breakdown: {domain_breakdown}")
        return domain_breakdown

1	import networkx as nx	3✔
2	from networkx.algorithms import approximation as approx	3✔
3
4	from sdx.datamodel.parsing.connectionhandler import ConnectionHandler	3✔
5	from sdx.pce.topology.manager import TopologyManager	3✔
6	from sdx.pce.models import ConnectionRequest, TrafficMatrix	3✔
7
8
9	class TEManager:	3✔
10
11	"""
12	TE Manager for connection - topology operations.
13
14	Functions of this class are:
15
16	- generate inputs to the PCE solver
17
18	- converter the solver output.
19	"""
20
21	def __init__(self, topology_data, connection_data):	3✔
22	super().__init__()	3✔
23
24	self.topology_manager = TopologyManager()	3✔
25	self.connection_handler = ConnectionHandler()	3✔
26
27	self.topology_manager.topology = (	3✔
28	self.topology_manager.get_handler().import_topology_data(topology_data)
29	)
30	self.connection = self.connection_handler.import_connection_data(	3✔
31	connection_data
32	)
33
34	self.graph = self.generate_graph_te()	3✔
35
36	def add_topology(self, topology_data: dict):	3✔
37	"""
38	Add a new topology to TEManager.
39
40	:param topology_data: a dictionary that represents a topology.
41	"""
42	self.topology_manager.add_topology(topology_data)	3✔
43
44	def generate_connection_te(self) -> TrafficMatrix:	3✔
45	"""
46	Generate a Traffic Matrix from the connection request we have.
47	"""
48	ingress_port = self.connection.ingress_port	3✔
49	ingress_node = self.topology_manager.topology.get_node_by_port(ingress_port.id)	3✔
50	egress_port = self.connection.egress_port	3✔
51	egress_node = self.topology_manager.topology.get_node_by_port(egress_port.id)	3✔
52
53	ingress_nodes = [	3✔
54	x for x, y in self.graph.nodes(data=True) if y["id"] == ingress_node.id
55	]
56
57	egress_nodes = [	3✔
58	x for x, y in self.graph.nodes(data=True) if y["id"] == egress_node.id
59	]
60
61	if len(ingress_nodes) <= 0:	3!
NEW 62	raise Exception("No ingress nodes found in the graph")	×
63
64	if len(egress_nodes) <= 0:	3!
NEW UNCOV 65	raise Exception("No egress nodes found in the graph")	×
66
67	required_bandwidth = self.connection.bandwidth	3✔
68	required_latency = self.connection.latency	3✔
69
70	request = ConnectionRequest(	3✔
71	source = ingress_nodes[0],
72	destination = egress_nodes[0],
73	required_bandwidth = required_bandwidth,
74	required_latency = required_latency
75	)
76
77	return TrafficMatrix(connection_requests=[request])	3✔
78
79	def generate_graph_te(self) -> nx.Graph:	3✔
80	"""
81	Return the topology graph that we have.
82	"""
83	graph = self.topology_manager.generate_graph()	3✔
84	graph = nx.convert_node_labels_to_integers(graph, label_attribute="id")	3✔
85
86	# TODO: why is this needed?
87	self.graph = graph	3✔
88	# print(list(graph.nodes(data=True)))
89
90	return graph	3✔
91
92	def graph_node_connectivity(self, source=None, dest=None):	3✔
UNCOV 93	conn = approx.node_connectivity(self.graph, source, dest)	×
94	return conn	×
95
96	def requests_connectivity(self, requests):	3✔
UNCOV 97	for request in requests:	×
98	conn = self.graph_node_connectivity(request[0], request[1])	×
99	print(	×
100	"Request Connectivity: {}, {} = {}".format(
101	request[0],
102	request[1],
103	conn,
104	)
105	)
106	return True	×
107
108	def generate_connection_breakdown(self, connection):	3✔
109	assert connection is not None	3✔
110
111	breakdown = {}	3✔
112	paths = connection[0] # p2p for now	3✔
113	# cost = connection[1]
114	i_port = None	3✔
115	e_port = None	3✔
116
117	print(f"Domain breakdown with graph: {self.graph}")	3✔
118	print(f"Graph nodes: {self.graph.nodes}")	3✔
119	print(f"Graph edges: {self.graph.edges}")	3✔
120
121	print(f"Paths: {paths}")	3✔
122
123	for i, j in paths.items():	3✔
124	print(f"i: {i}, j: {j}")	3✔
125	current_link_set = []	3✔
126	for count, link in enumerate(j):	3✔
127	print(f"count: {count}, link: {link}")	3✔
128	assert len(link) == 2	3✔
129
130	node_1 = self.graph.nodes.get(link[0])	3✔
131	assert node_1 is not None	3✔
132
133	node_2 = self.graph.nodes.get(link[1])	3✔
134	assert node_2 is not None	3✔
135
136	print(f"node_1: {node_1}, node_2: {node_2}")	3✔
137
138	domain_1 = self.topology_manager.get_domain_name(node_1["id"])	3✔
139	domain_2 = self.topology_manager.get_domain_name(node_2["id"])	3✔
140
141	# # TODO: handle the cases where a domain was not found.
142	# if domain_1 is None:
143	# domain_1 = f"domain_{i}"
144	# if domain_2 is None:
145	# domain_2 = f"domain_{i}"
146
147	print(f"domain_1: {domain_1}, domain_2: {domain_2}")	3✔
148
149	current_link_set.append(link)	3✔
150	current_domain = domain_1	3✔
151	if domain_1 == domain_2:	3!
152	# current_domain = domain_1
153	if count == len(j) - 1:	3✔
154	breakdown[current_domain] = current_link_set.copy()	3✔
155	else:
156	breakdown[current_domain] = current_link_set.copy()	×
157	current_domain = None	×
158	current_link_set = []	×
159
160	print(f"[intermediate] breakdown: {breakdown}")	3✔
161
162	# now starting with the ingress_port
163	first = True	3✔
164	i = 0	3✔
165	domain_breakdown = {}	3✔
166
167	for domain, links in breakdown.items():	3✔
168	print(f"Creating domain_breakdown: domain: {domain}, links: {links}")	3✔
169	segment = {}	3✔
170	if first:	3!
171	first = False	3✔
172	last_link = links[-1]	3✔
173	n1 = self.graph.nodes[last_link[0]]["id"]	3✔
174	n2 = self.graph.nodes[last_link[1]]["id"]	3✔
175	n1, p1, n2, p2 = self.topology_manager.topology.get_port_by_link(n1, n2)	3✔
176	i_port = self.connection.ingress_port.to_dict()	3✔
177	e_port = p1	3✔
178	next_i = p2	3✔
179	elif i == len(breakdown) - 1:	×
180	i_port = next_i	×
181	e_port = self.connection.egress_port.to_dict()	×
182	else:
183	last_link = links[-1]	×
184	n1 = self.graph.nodes[last_link[0]]["id"]	×
185	n2 = self.graph.nodes[last_link[1]]["id"]	×
NEW 186	n1, p1, n2, p2 = self.topology_manager.topology.get_port_by_link(n1, n2)	×
187	i_port = next_i	×
188	e_port = p1	×
189	next_i = p2	×
190	segment["ingress_port"] = i_port	3✔
191	segment["egress_port"] = e_port	3✔
192	domain_breakdown[domain] = segment.copy()	3✔
193	i = i + 1	3✔
194
195	print(f"generate_connection_breakdown(): domain_breakdown: {domain_breakdown}")	3✔
196	return domain_breakdown	3✔

atlanticwave-sdx / pce / 4128844271

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous