build.loop_manager.LoopManager.del_interface_metadata() - Code Metrics - Inspection of "Updated tox.ini and removed `tests_require` and `s..." - kytos-ng/of_lldp - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#52)

by Vinicius

created 2022-06-14 14:35 UTC

LoopManager.del_interface_metadata() A

↳ Parent: build.loop_manager

Complexity

Conditions

Size

Total Lines	5
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	4
nop	3
dl	0
loc	5
ccs	4
cts	4
cp	1
crap	1
rs	10
c	0
b	0
f	0

"""LoopManager."""
from collections import defaultdict
from enum import Enum
from threading import Lock

import requests

from kytos.core import KytosEvent, log
from kytos.core.helpers import get_time, now
from napps.kytos.of_lldp import settings as napp_settings


class LoopState(str, Enum):
    """LoopState Enum."""

    detected = "detected"
    stopped = "stopped"


class LoopManager:
    """LoopManager."""

    def __init__(self, controller, settings=napp_settings):
        """Constructor of LoopDetection."""
        self.controller = controller
        self.loop_lock = Lock()
        self.loop_counter = defaultdict(dict)
        self.loop_state = defaultdict(dict)

        self.settings = settings
        self.ignored_loops = settings.LLDP_IGNORED_LOOPS
        self.actions = settings.LLDP_LOOP_ACTIONS
        self.stopped_interval = 3 * settings.POLLING_TIME
        self.log_every = settings.LOOP_LOG_EVERY

    def is_loop_ignored(self, dpid, port_a, port_b):
        """Check if a loop is ignored."""
        if dpid not in self.ignored_loops:
            return False
        if any(
            (
                [port_a, port_b] in self.ignored_loops[dpid],
                [port_b, port_a] in self.ignored_loops[dpid],
            )
        ):
            return True
        return False

    @staticmethod
    def is_looped(dpid_a, port_a, dpid_b, port_b):
        """Check if the given dpids and ports are looped."""
        if all((dpid_a == dpid_b, port_a <= port_b)):  # only enter one pair
            return True
        return False

    def process_if_looped(
        self,
        interface_a,
        interface_b,
    ):
        """Process if interface_a and interface_b are looped."""
        dpid_a = interface_a.switch.dpid
        dpid_b = interface_b.switch.dpid
        port_a = interface_a.port_number
        port_b = interface_b.port_number
        if all(
            (
                self.is_looped(dpid_a, port_a, dpid_b, port_b),
                not self.is_loop_ignored(dpid_a, port_a, port_b),
            )
        ):
            self.publish_loop_state(
                interface_a, interface_b, LoopState.detected.value
            )
            self.publish_loop_actions(interface_a, interface_b)
            return True
        return False

    def publish_loop_state(
        self,
        interface_a,
        interface_b,
        state,
    ):
        """Publish loop state event."""
        dpid = interface_a.switch.dpid
        port_a = interface_a.port_number
        port_b = interface_b.port_number
        event = KytosEvent(
            name=f"kytos/of_lldp.loop.{state}",
            content={
                "interface_id": interface_a.id,
                "dpid": dpid,
                "port_numbers": [port_a, port_b],
            },
        )
        self.controller.buffers.app.put(event)

    def publish_loop_actions(
        self,
        interface_a,
        interface_b,
    ):
        """Publish loop action events."""
        supported_actions = {"log", "disable"}
        for action in set(self.actions).intersection(supported_actions):
            event = KytosEvent(
                name=f"kytos/of_lldp.loop.action.{action}",
                content={
                    "interface_a": interface_a,
                    "interface_b": interface_b,
                },
            )
            self.controller.buffers.app.put(event)

    def handle_loop_detected(self, interface_id, dpid, port_pair):
        """Handle loop detected."""
        is_new_loop = False
        port_pair = tuple(port_pair)
        with self.loop_lock:
            if port_pair not in self.loop_state[dpid]:
                dt_at = now().strftime("%Y-%m-%dT%H:%M:%S")
                data = {
                    "state": LoopState.detected.value,
                    "port_numbers": list(port_pair),
                    "updated_at": dt_at,
                    "detected_at": dt_at,
                }
                self.loop_state[dpid][port_pair] = data
                is_new_loop = True
            if (
                self.loop_state[dpid][port_pair]["state"]
                != LoopState.detected.value
            ):
                dt_at = now().strftime("%Y-%m-%dT%H:%M:%S")
                data = {
                    "state": LoopState.detected.value,
                    "updated_at": dt_at,
                    "detected_at": dt_at,
                }
                self.loop_state[dpid][port_pair].update(data)
                self.loop_state[dpid][port_pair].pop("stopped_at", None)
                is_new_loop = True
            else:
                data = {"updated_at": now().strftime("%Y-%m-%dT%H:%M:%S")}
                self.loop_state[dpid][port_pair].update(data)
        if is_new_loop:
            port_numbers = self.loop_state[dpid][port_pair]["port_numbers"]
            detected_at = self.loop_state[dpid][port_pair]["detected_at"]
            metadata = {
                "looped": {
                    "port_numbers": port_numbers,
                    "detected_at": detected_at,
                }
            }
            response = self.add_interface_metadata(interface_id, metadata)
            if response.status_code != 201:
                log.error(
                    f"Failed to add metadata {metadata} on interface "
                    f"{interface_id}, response: {response.json()}"
                )

    def has_loop_stopped(self, dpid, port_pair):
        """Check if a loop has stopped by checking within an interval
        or based on their operational state."""
        data = self.loop_state[dpid].get(port_pair)
        switch = self.controller.get_switch_by_dpid(dpid)
        if not data or not switch:
            return None
        try:
            interface_a = switch.interfaces[port_pair[0]]
            interface_b = switch.interfaces[port_pair[1]]
        except KeyError:
            return None

        if not interface_a.is_active() or not interface_b.is_active():
            return True

        delta_seconds = (now() - get_time(data["updated_at"])).seconds
        if delta_seconds > self.stopped_interval:
            return True
        return False

    def get_stopped_loops(self):
        """Get stopped loops."""
        stopped_loops = {}
        for key, state_dict in self.loop_state.items():
            for port_pair, values in state_dict.items():
                if values["state"] != LoopState.detected.value:
                    continue
                if self.has_loop_stopped(key, port_pair):
                    if key not in stopped_loops:
                        stopped_loops[key] = [port_pair]
                    else:
                        stopped_loops[key].append(port_pair)
        return stopped_loops

    def add_interface_metadata(self, interface_id, metadata):
        """Add interface metadata."""
        base_url = self.settings.TOPOLOGY_URL
        endpoint = f"{base_url}/interfaces/{interface_id}/metadata"
        return requests.post(endpoint, json=metadata)

    def del_interface_metadata(self, interface_id, key):
        """Delete interface metadata."""
        base_url = self.settings.TOPOLOGY_URL
        endpoint = f"{base_url}/interfaces/{interface_id}/metadata/{key}"
        return requests.delete(endpoint)

    def handle_loop_stopped(self, interface_a, interface_b):
        """Handle loop stopped."""
        dpid = interface_a.switch.dpid
        port_a = interface_a.port_number
        port_b = interface_b.port_number
        port_pair = (port_a, port_b)

        if port_pair not in self.loop_state[dpid]:
            return
        with self.loop_lock:
            dt_at = now().strftime("%Y-%m-%dT%H:%M:%S")
            data = {
                "state": "stopped",
                "updated_at": dt_at,
                "stopped_at": dt_at,
            }
            self.loop_state[dpid][port_pair].update(data)

        if "log" in self.actions:
            log.info(
                f"LLDP loop stopped on switch: {dpid}, "
                f"interfaces: {[interface_a.name, interface_b.name]}, "
                f"port_numbers: {[port_a, port_b]}"
            )
        if "disable" in self.actions:
            base_url = self.settings.TOPOLOGY_URL
            endpoint = f"{base_url}/interfaces/{interface_a.id}/enable"
            response = requests.post(endpoint)
            if response.status_code != 200:
                log.error(
                    f"Failed to enable interface: {interface_a.id},"
                    f" status code: {response.status_code}"
                )
            else:
                log.info(
                    "LLDP loop detection enabled interface "
                    f"{interface_a.id}, looped interfaces: "
                    f"{[interface_a.name, interface_b.name]},"
                    f"port_numbers: {[port_a, port_b]}"
                )

        key = "looped"
        response = self.del_interface_metadata(interface_a.id, key)
        if response.status_code != 200:
            log.error(
                f"Failed to delete metadata key {key} on interface ",
                f"{interface_a.id}",
            )

    def handle_log_action(
        self,
        interface_a,
        interface_b,
    ):
        """Execute loop log action."""
        dpid = interface_a.switch.dpid
        port_a = interface_a.port_number
        port_b = interface_b.port_number
        port_pair = (port_a, port_b)
        log_every = self.log_every
        with self.loop_lock:
            if port_pair not in self.loop_counter[dpid]:
                self.loop_counter[dpid][port_pair] = 0
            else:
                self.loop_counter[dpid][port_pair] += 1
                self.loop_counter[dpid][port_pair] %= log_every
            count = self.loop_counter[dpid][port_pair]
            if count != 0:
                return

        log.warning(
            f"LLDP loop detected on switch: {dpid}, "
            f"interfaces: {[interface_a.name, interface_b.name]}, "
            f"port_numbers: {[port_a, port_b]}"
        )

    def handle_disable_action(
        self,
        interface_a,
        interface_b,
    ):
        """Execute LLDP loop disable action idempotently."""
        if not interface_a.is_enabled():
            return

        port_a = interface_a.port_number
        port_b = interface_b.port_number
        intf_id = interface_a.id
        base_url = self.settings.TOPOLOGY_URL
        endpoint = f"{base_url}/interfaces/{intf_id}/disable"
        response = requests.post(endpoint)
        if response.status_code != 200:
            log.error(
                f"Failed to disable interface: {intf_id},"
                f" status code: {response.status_code}"
            )
            return

        log.info(
            f"LLDP loop detection disabled interface {interface_a.id}, "
            f"looped interfaces: {[interface_a.name, interface_b.name]}, "
            f"port_numbers: {[port_a, port_b]}"
        )

    def handle_switch_metadata_changed(self, switch):
        """Handle switch metadata changed."""
        if "ignored_loops" not in switch.metadata:
            with self.loop_lock:
                return self.ignored_loops.pop(switch.dpid, None)
        return self.try_to_load_ignored_switch(switch)

    def try_to_load_ignored_switch(self, switch):
        """Try to load an ignored switch."""
        if "ignored_loops" not in switch.metadata:
            return
        if not isinstance(switch.metadata["ignored_loops"], list):
            return

        dpid = switch.dpid
        with self.loop_lock:
            self.ignored_loops[dpid] = []
            for port_pair in switch.metadata["ignored_loops"]:
                if isinstance(port_pair, list):
                    self.ignored_loops[dpid].append(port_pair)

    def handle_topology_loaded(self, topology):
        """Handle on topology loaded."""
        for switch in topology.switches.values():
            self.try_to_load_ignored_switch(switch)


1		"""LoopManager."""
2	1	from collections import defaultdict
3	1	from enum import Enum
4	1	from threading import Lock
5
6	1	import requests
7
8	1	from kytos.core import KytosEvent, log
9	1	from kytos.core.helpers import get_time, now
10	1	from napps.kytos.of_lldp import settings as napp_settings
11
12
13	1	class LoopState(str, Enum):
14		"""LoopState Enum."""
15
16	1	detected = "detected"
17	1	stopped = "stopped"
18
19
20	1	class LoopManager:
21		"""LoopManager."""
22
23	1	def __init__(self, controller, settings=napp_settings):
24		"""Constructor of LoopDetection."""
25	1	self.controller = controller
26	1	self.loop_lock = Lock()
27	1	self.loop_counter = defaultdict(dict)
28	1	self.loop_state = defaultdict(dict)
29
30	1	self.settings = settings
31	1	self.ignored_loops = settings.LLDP_IGNORED_LOOPS
32	1	self.actions = settings.LLDP_LOOP_ACTIONS
33	1	self.stopped_interval = 3 * settings.POLLING_TIME
34	1	self.log_every = settings.LOOP_LOG_EVERY
35
36	1	def is_loop_ignored(self, dpid, port_a, port_b):
37		"""Check if a loop is ignored."""
38	1	if dpid not in self.ignored_loops:
39	1	return False
40	1	if any(
41		(
42		[port_a, port_b] in self.ignored_loops[dpid],
43		[port_b, port_a] in self.ignored_loops[dpid],
44		)
45		):
46	1	return True
47	1	return False
48
49	1	@staticmethod
50	1	def is_looped(dpid_a, port_a, dpid_b, port_b):
51		"""Check if the given dpids and ports are looped."""
52	1	if all((dpid_a == dpid_b, port_a <= port_b)): # only enter one pair
53	1	return True
54	1	return False
55
56	1	def process_if_looped(
57		self,
58		interface_a,
59		interface_b,
60		):
61		"""Process if interface_a and interface_b are looped."""
62	1	dpid_a = interface_a.switch.dpid
63	1	dpid_b = interface_b.switch.dpid
64	1	port_a = interface_a.port_number
65	1	port_b = interface_b.port_number
66	1	if all(
67		(
68		self.is_looped(dpid_a, port_a, dpid_b, port_b),
69		not self.is_loop_ignored(dpid_a, port_a, port_b),
70		)
71		):
72	1	self.publish_loop_state(
73		interface_a, interface_b, LoopState.detected.value
74		)
75	1	self.publish_loop_actions(interface_a, interface_b)
76	1	return True
77		return False
78
79	1	def publish_loop_state(
80		self,
81		interface_a,
82		interface_b,
83		state,
84		):
85		"""Publish loop state event."""
86	1	dpid = interface_a.switch.dpid
87	1	port_a = interface_a.port_number
88	1	port_b = interface_b.port_number
89	1	event = KytosEvent(
90		name=f"kytos/of_lldp.loop.{state}",
91		content={
92		"interface_id": interface_a.id,
93		"dpid": dpid,
94		"port_numbers": [port_a, port_b],
95		},
96		)
97	1	self.controller.buffers.app.put(event)
98
99	1	def publish_loop_actions(
100		self,
101		interface_a,
102		interface_b,
103		):
104		"""Publish loop action events."""
105	1	supported_actions = {"log", "disable"}
106	1	for action in set(self.actions).intersection(supported_actions):
107	1	event = KytosEvent(
108		name=f"kytos/of_lldp.loop.action.{action}",
109		content={
110		"interface_a": interface_a,
111		"interface_b": interface_b,
112		},
113		)
114	1	self.controller.buffers.app.put(event)
115
116	1	def handle_loop_detected(self, interface_id, dpid, port_pair):
117		"""Handle loop detected."""
118	1	is_new_loop = False
119	1	port_pair = tuple(port_pair)
120	1	with self.loop_lock:
121	1	if port_pair not in self.loop_state[dpid]:
122	1	dt_at = now().strftime("%Y-%m-%dT%H:%M:%S")
123	1	data = {
124		"state": LoopState.detected.value,
125		"port_numbers": list(port_pair),
126		"updated_at": dt_at,
127		"detected_at": dt_at,
128		}
129	1	self.loop_state[dpid][port_pair] = data
130	1	is_new_loop = True
131	1	if (
132		self.loop_state[dpid][port_pair]["state"]
133		!= LoopState.detected.value
134		):
135	1	dt_at = now().strftime("%Y-%m-%dT%H:%M:%S")
136	1	data = {
137		"state": LoopState.detected.value,
138		"updated_at": dt_at,
139		"detected_at": dt_at,
140		}
141	1	self.loop_state[dpid][port_pair].update(data)
142	1	self.loop_state[dpid][port_pair].pop("stopped_at", None)
143	1	is_new_loop = True
144		else:
145	1	data = {"updated_at": now().strftime("%Y-%m-%dT%H:%M:%S")}
146	1	self.loop_state[dpid][port_pair].update(data)
147	1	if is_new_loop:
148	1	port_numbers = self.loop_state[dpid][port_pair]["port_numbers"]
149	1	detected_at = self.loop_state[dpid][port_pair]["detected_at"]
150	1	metadata = {
151		"looped": {
152		"port_numbers": port_numbers,
153		"detected_at": detected_at,
154		}
155		}
156	1	response = self.add_interface_metadata(interface_id, metadata)
157	1	if response.status_code != 201:
158	1	log.error(
159		f"Failed to add metadata {metadata} on interface "
160		f"{interface_id}, response: {response.json()}"
161		)
162
163	1	def has_loop_stopped(self, dpid, port_pair):
164		"""Check if a loop has stopped by checking within an interval
165		or based on their operational state."""
166	1	data = self.loop_state[dpid].get(port_pair)
167	1	switch = self.controller.get_switch_by_dpid(dpid)
168	1	if not data or not switch:
169		return None
170	1	try:
171	1	interface_a = switch.interfaces[port_pair[0]]
172	1	interface_b = switch.interfaces[port_pair[1]]
173		except KeyError:
174		return None
175
176	1	if not interface_a.is_active() or not interface_b.is_active():
177		return True
178
179	1	delta_seconds = (now() - get_time(data["updated_at"])).seconds
180	1	if delta_seconds > self.stopped_interval:
181	1	return True
182		return False
183
184	1	def get_stopped_loops(self):
185		"""Get stopped loops."""
186	1	stopped_loops = {}
187	1	for key, state_dict in self.loop_state.items():
188	1	for port_pair, values in state_dict.items():
189	1	if values["state"] != LoopState.detected.value:
190		continue
191	1	if self.has_loop_stopped(key, port_pair):
192	1	if key not in stopped_loops:
193	1	stopped_loops[key] = [port_pair]
194		else:
195	1	stopped_loops[key].append(port_pair)
196	1	return stopped_loops
197
198	1	def add_interface_metadata(self, interface_id, metadata):
199		"""Add interface metadata."""
200	1	base_url = self.settings.TOPOLOGY_URL
201	1	endpoint = f"{base_url}/interfaces/{interface_id}/metadata"
202	1	return requests.post(endpoint, json=metadata)
203
204	1	def del_interface_metadata(self, interface_id, key):
205		"""Delete interface metadata."""
206	1	base_url = self.settings.TOPOLOGY_URL
207	1	endpoint = f"{base_url}/interfaces/{interface_id}/metadata/{key}"
208	1	return requests.delete(endpoint)
209
210	1	def handle_loop_stopped(self, interface_a, interface_b):
211		"""Handle loop stopped."""
212	1	dpid = interface_a.switch.dpid
213	1	port_a = interface_a.port_number
214	1	port_b = interface_b.port_number
215	1	port_pair = (port_a, port_b)
216
217	1	if port_pair not in self.loop_state[dpid]:
218		return
219	1	with self.loop_lock:
220	1	dt_at = now().strftime("%Y-%m-%dT%H:%M:%S")
221	1	data = {
222		"state": "stopped",
223		"updated_at": dt_at,
224		"stopped_at": dt_at,
225		}
226	1	self.loop_state[dpid][port_pair].update(data)
227
228	1	if "log" in self.actions:
229	1	log.info(
230		f"LLDP loop stopped on switch: {dpid}, "
231		f"interfaces: {[interface_a.name, interface_b.name]}, "
232		f"port_numbers: {[port_a, port_b]}"
233		)
234	1	if "disable" in self.actions:
235	1	base_url = self.settings.TOPOLOGY_URL
236	1	endpoint = f"{base_url}/interfaces/{interface_a.id}/enable"
237	1	response = requests.post(endpoint)
238	1	if response.status_code != 200:
239		log.error(
240		f"Failed to enable interface: {interface_a.id},"
241		f" status code: {response.status_code}"
242		)
243		else:
244	1	log.info(
245		"LLDP loop detection enabled interface "
246		f"{interface_a.id}, looped interfaces: "
247		f"{[interface_a.name, interface_b.name]},"
248		f"port_numbers: {[port_a, port_b]}"
249		)
250
251	1	key = "looped"
252	1	response = self.del_interface_metadata(interface_a.id, key)
253	1	if response.status_code != 200:
254	1	log.error(
255		f"Failed to delete metadata key {key} on interface ",
256		f"{interface_a.id}",
257		)
258
259	1	def handle_log_action(
260		self,
261		interface_a,
262		interface_b,
263		):
264		"""Execute loop log action."""
265	1	dpid = interface_a.switch.dpid
266	1	port_a = interface_a.port_number
267	1	port_b = interface_b.port_number
268	1	port_pair = (port_a, port_b)
269	1	log_every = self.log_every
270	1	with self.loop_lock:
271	1	if port_pair not in self.loop_counter[dpid]:
272	1	self.loop_counter[dpid][port_pair] = 0
273		else:
274	1	self.loop_counter[dpid][port_pair] += 1
275	1	self.loop_counter[dpid][port_pair] %= log_every
276	1	count = self.loop_counter[dpid][port_pair]
277	1	if count != 0:
278	1	return
279
280	1	log.warning(
281		f"LLDP loop detected on switch: {dpid}, "
282		f"interfaces: {[interface_a.name, interface_b.name]}, "
283		f"port_numbers: {[port_a, port_b]}"
284		)
285
286	1	def handle_disable_action(
287		self,
288		interface_a,
289		interface_b,
290		):
291		"""Execute LLDP loop disable action idempotently."""
292	1	if not interface_a.is_enabled():
293		return
294
295	1	port_a = interface_a.port_number
296	1	port_b = interface_b.port_number
297	1	intf_id = interface_a.id
298	1	base_url = self.settings.TOPOLOGY_URL
299	1	endpoint = f"{base_url}/interfaces/{intf_id}/disable"
300	1	response = requests.post(endpoint)
301	1	if response.status_code != 200:
302		log.error(
303		f"Failed to disable interface: {intf_id},"
304		f" status code: {response.status_code}"
305		)
306		return
307
308	1	log.info(
309		f"LLDP loop detection disabled interface {interface_a.id}, "
310		f"looped interfaces: {[interface_a.name, interface_b.name]}, "
311		f"port_numbers: {[port_a, port_b]}"
312		)
313
314	1	def handle_switch_metadata_changed(self, switch):
315		"""Handle switch metadata changed."""
316	1	if "ignored_loops" not in switch.metadata:
317	1	with self.loop_lock:
318	1	return self.ignored_loops.pop(switch.dpid, None)
319	1	return self.try_to_load_ignored_switch(switch)
320
321	1	def try_to_load_ignored_switch(self, switch):
322		"""Try to load an ignored switch."""
323	1	if "ignored_loops" not in switch.metadata:
324		return
325	1	if not isinstance(switch.metadata["ignored_loops"], list):
326		return
327
328	1	dpid = switch.dpid
329	1	with self.loop_lock:
330	1	self.ignored_loops[dpid] = []
331	1	for port_pair in switch.metadata["ignored_loops"]:
332	1	if isinstance(port_pair, list):
333	1	self.ignored_loops[dpid].append(port_pair)
334
335	1	def handle_topology_loaded(self, topology):
336		"""Handle on topology loaded."""
337	1	for switch in topology.switches.values():
338		self.try_to_load_ignored_switch(switch)
339

kytos-ng / of_lldp

Pull Request — master (#52)

LoopManager.del_interface_metadata() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like