build.main.Main.has_loop() - Code Metrics - Inspection of "feature: Remove parameters `last_id` and `traces`..." - kytos-ng/sdntrace_cp - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#90)

unknown

created 2023-04-10 15:43 UTC

build.main.Main.has_loop() A

↳ Parent: build.main

Complexity

Conditions

Size

Total Lines	8
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	4

Importance

Changes

Metric	Value
cc	4
eloc	7
nop	2
dl	0
loc	8
rs	10
c	0
b	0
f	0
ccs	6
cts	6
cp	1
crap	4

"""Main module of amlight/sdntrace_cp Kytos Network Application.

Run tracepaths on OpenFlow in the Control Plane
"""

import ipaddress
import pathlib
from datetime import datetime

from flask import jsonify
from kytos.core import KytosNApp, log, rest
from kytos.core.helpers import load_spec, validate_openapi
from napps.amlight.sdntrace_cp import settings
from napps.amlight.sdntrace_cp.automate import Automate
from napps.amlight.sdntrace_cp.utils import (convert_entries,
                                             convert_list_entries,
                                             find_endpoint, get_stored_flows,
                                             match_field_dl_vlan, prepare_json)


class Main(KytosNApp):
    """Main class of amlight/sdntrace_cp NApp.

    This application gets the list of flows from the switches
    and uses it to trace paths without using the data plane.
    """

    spec = load_spec(pathlib.Path(__file__).parent / "openapi.yml")

    def setup(self):
        """Replace the '__init__' method for the KytosNApp subclass.

        The setup method is automatically called by the controller when your
        application is loaded.

        """
        log.info("Starting Kytos SDNTrace CP App!")

        self.automate = Automate(self)
        self.automate.schedule_traces()
        self.automate.schedule_important_traces()

    def execute(self):
        """This method is executed right after the setup method execution.

        You can also use this method in loop mode if you add to the above setup
        method a line like the following example:

            self.execute_as_loop(30)  # 30-second interval.
        """

    def shutdown(self):
        """This method is executed when your napp is unloaded.

        If you have some cleanup procedure, insert it here.
        """
        self.automate.unschedule_ids()
        self.automate.sheduler_shutdown(wait=False)

    @rest('/trace', methods=['PUT'])
    @validate_openapi(spec)
    def trace(self, data):
        """Trace a path."""
        result = []
        entries = convert_entries(data)
        if not entries:
            return "Bad request", 400
        stored_flows = get_stored_flows()
        result = self.tracepath(entries, stored_flows)
        return jsonify(prepare_json(result))

    @rest('/traces', methods=['PUT'])
    @validate_openapi(spec)
    def get_traces(self, data):
        """For bulk requests."""
        entries = convert_list_entries(data)
        stored_flows = get_stored_flows()
        results = []
        for entry in entries:
            results.append(self.tracepath(entry, stored_flows))
        temp = prepare_json(results)
        return jsonify(temp)

    def tracepath(self, entries, stored_flows):
        """Trace a path for a packet represented by entries."""
        # pylint: disable=too-many-branches
        trace_result = []
        trace_type = 'starting'
        do_trace = True
        while do_trace:
            if 'dpid' not in entries or 'in_port' not in entries:
                break
            trace_step = {'in': {'dpid': entries['dpid'],
                                 'port': entries['in_port'],
                                 'time': str(datetime.now()),
                                 'type': trace_type}}
            if 'dl_vlan' in entries:
                trace_step['in'].update({'vlan': entries['dl_vlan'][-1]})

            switch = self.controller.get_switch_by_dpid(entries['dpid'])
            if not switch:
                trace_step['in']['type'] = 'last'
                trace_result.append(trace_step)
                break
            result = self.trace_step(switch, entries, stored_flows)
            if result:
                out = {'port': result['out_port']}
                if 'dl_vlan' in result['entries']:
                    out.update({'vlan': result['entries']['dl_vlan'][-1]})
                trace_step.update({
                    'out': out
                })
                if 'dpid' in result:
                    next_step = {'dpid': result['dpid'],
                                 'port': result['in_port']}
                    entries = result['entries']
                    entries['dpid'] = result['dpid']
                    entries['in_port'] = result['in_port']
                    if self.has_loop(next_step, trace_result):
                        trace_step['in']['type'] = 'loop'
                        do_trace = False
                    else:
                        trace_type = 'intermediary'
                else:
                    trace_step['in']['type'] = 'last'
                    do_trace = False
            else:
                trace_step['in']['type'] = 'incomplete'
                do_trace = False
            if 'out' in trace_step and trace_step['out']:
                if self.check_loop_trace_step(trace_step, trace_result):
                    do_trace = False
            trace_result.append(trace_step)
        return trace_result

    @staticmethod
    def check_loop_trace_step(trace_step, trace_result):
        """Check if there is a loop in the trace and add the step."""
        # outgoing interface is the same as the input interface
        if not trace_result and \
                trace_step['in']['type'] == 'last' and \
                trace_step['in']['port'] == trace_step['out']['port']:
            trace_step['in']['type'] = 'loop'
            return True
        if trace_result and \
                trace_result[0]['in']['dpid'] == trace_step['in']['dpid'] and \
                trace_result[0]['in']['port'] == trace_step['out']['port']:
            trace_step['in']['type'] = 'loop'
            return True
        return False

    @staticmethod
    def has_loop(trace_step, trace_result):
        """Check if there is a loop in the trace result."""
        for trace in trace_result:
            if trace['in']['dpid'] == trace_step['dpid'] and \
                            trace['in']['port'] == trace_step['port']:
                return True
        return False

    def trace_step(self, switch, entries, stored_flows):
        """Perform a trace step.

        Match the given fields against the switch's list of flows."""
        flow, entries, port = self.match_and_apply(
                                                    switch,
                                                    entries,
                                                    stored_flows
                                                )

        if not flow or not port:
            return None

        endpoint = find_endpoint(switch, port)
        if endpoint is None:
            return {'out_port': port,
                    'entries': entries}

        return {'dpid': endpoint.switch.dpid,
                'in_port': endpoint.port_number,
                'out_port': port,
                'entries': entries}

    def update_circuits(self):
        """Update the list of circuits after a flow change."""
        # pylint: disable=unused-argument
        if settings.FIND_CIRCUITS_IN_FLOWS:
            self.automate.find_circuits()

    @classmethod
    def do_match(cls, flow, args):
        """Match a packet against this flow (OF1.3)."""
        # pylint: disable=consider-using-dict-items
        # pylint: disable=too-many-return-statements
        if ('match' not in flow['flow']) or (len(flow['flow']['match']) == 0):
            return False
        for name in flow['flow']['match']:
            field_flow = flow['flow']['match'][name]
            if name == 'dl_vlan':
                field = args.get(name)
                if field:
                    field = field[-1]
                if not match_field_dl_vlan(field, field_flow):
                    return False
                continue
            if name not in args:
                return False
            field = args[name]
            if name not in ('ipv4_src', 'ipv4_dst', 'ipv6_src', 'ipv6_dst'):
                if field_flow != field:
                    return False
            else:
                packet_ip = int(ipaddress.ip_address(field))
                ip_addr = flow['flow']['match'][name]
                if packet_ip & ip_addr.netmask != ip_addr.address:
                    return False
        return flow

    def match_flows(self, switch, args, stored_flows, many=True):
        # pylint: disable=bad-staticmethod-argument
        """
        Match the packet in request against the stored flows from flow_manager.
        Try the match with each flow, in other. If many is True, tries the
        match with all flows, if False, tries until the first match.
        :param args: packet data
        :param many: Boolean, indicating whether to continue after matching the
                first flow or not
        :return: If many, the list of matched flows, or the matched flow
        """
        if switch.dpid not in stored_flows:
            return None
        response = []
        if switch.dpid not in stored_flows:
            return None
        try:
            for flow in stored_flows[switch.dpid]:
                match = Main.do_match(flow, args)
                if match:
                    if many:
                        response.append(match)
                    else:
                        response = match
                        break
        except AttributeError:
            return None
        if not many and isinstance(response, list):
            return None
        return response

    # pylint: disable=redefined-outer-name
    def match_and_apply(self, switch, args, stored_flows):
        # pylint: disable=bad-staticmethod-argument
        """Match flows and apply actions.
        Match given packet (in args) against
        the stored flows (from flow_manager) and,
        if a match flow is found, apply its actions."""
        flow = self.match_flows(switch, args, stored_flows, False)
        port = None
        actions = []
        # pylint: disable=too-many-nested-blocks
        if not flow or switch.ofp_version != '0x04':
            return flow, args, port
        if 'actions' in flow['flow']:
            actions = flow['flow']['actions']
        for action in actions:
            action_type = action['action_type']
            if action_type == 'output':
                port = action['port']
            if action_type == 'push_vlan':
                if 'dl_vlan' not in args:
                    args['dl_vlan'] = []
                args['dl_vlan'].append(0)
            if action_type == 'pop_vlan':
                if 'dl_vlan' in args:
                    args['dl_vlan'].pop()
                    if len(args['dl_vlan']) == 0:
                        del args['dl_vlan']
            if action_type == 'set_vlan':
                args['dl_vlan'][-1] = action['vlan_id']
        return flow, args, port


1		"""Main module of amlight/sdntrace_cp Kytos Network Application.
2
3		Run tracepaths on OpenFlow in the Control Plane
4		"""
5
6	1	import ipaddress
7	1	import pathlib
8	1	from datetime import datetime
9
10	1	from flask import jsonify
11	1	from kytos.core import KytosNApp, log, rest
12	1	from kytos.core.helpers import load_spec, validate_openapi
13	1	from napps.amlight.sdntrace_cp import settings
14	1	from napps.amlight.sdntrace_cp.automate import Automate
15	1	from napps.amlight.sdntrace_cp.utils import (convert_entries,
16		convert_list_entries,
17		find_endpoint, get_stored_flows,
18		match_field_dl_vlan, prepare_json)
19
20
21	1	class Main(KytosNApp):
22		"""Main class of amlight/sdntrace_cp NApp.
23
24		This application gets the list of flows from the switches
25		and uses it to trace paths without using the data plane.
26		"""
27
28	1	spec = load_spec(pathlib.Path(__file__).parent / "openapi.yml")
29
30	1	def setup(self):
31		"""Replace the '__init__' method for the KytosNApp subclass.
32
33		The setup method is automatically called by the controller when your
34		application is loaded.
35
36		"""
37	1	log.info("Starting Kytos SDNTrace CP App!")
38
39	1	self.automate = Automate(self)
40	1	self.automate.schedule_traces()
41	1	self.automate.schedule_important_traces()
42
43	1	def execute(self):
44		"""This method is executed right after the setup method execution.
45
46		You can also use this method in loop mode if you add to the above setup
47		method a line like the following example:
48
49		self.execute_as_loop(30) # 30-second interval.
50		"""
51
52	1	def shutdown(self):
53		"""This method is executed when your napp is unloaded.
54
55		If you have some cleanup procedure, insert it here.
56		"""
57		self.automate.unschedule_ids()
58		self.automate.sheduler_shutdown(wait=False)
59
60	1	@rest('/trace', methods=['PUT'])
61	1	@validate_openapi(spec)
62	1	def trace(self, data):
63		"""Trace a path."""
64	1	result = []
65	1	entries = convert_entries(data)
66	1	if not entries:
67		return "Bad request", 400
68	1	stored_flows = get_stored_flows()
69	1	result = self.tracepath(entries, stored_flows)
70	1	return jsonify(prepare_json(result))
71
72	1	@rest('/traces', methods=['PUT'])
73	1	@validate_openapi(spec)
74	1	def get_traces(self, data):
75		"""For bulk requests."""
76	1	entries = convert_list_entries(data)
77	1	stored_flows = get_stored_flows()
78	1	results = []
79	1	for entry in entries:
80	1	results.append(self.tracepath(entry, stored_flows))
81	1	temp = prepare_json(results)
82	1	return jsonify(temp)
83
84	1	def tracepath(self, entries, stored_flows):
85		"""Trace a path for a packet represented by entries."""
86		# pylint: disable=too-many-branches
87	1	trace_result = []
88	1	trace_type = 'starting'
89	1	do_trace = True
90	1	while do_trace:
91	1	if 'dpid' not in entries or 'in_port' not in entries:
92		break
93	1	trace_step = {'in': {'dpid': entries['dpid'],
94		'port': entries['in_port'],
95		'time': str(datetime.now()),
96		'type': trace_type}}
97	1	if 'dl_vlan' in entries:
98	1	trace_step['in'].update({'vlan': entries['dl_vlan'][-1]})
99
100	1	switch = self.controller.get_switch_by_dpid(entries['dpid'])
101	1	if not switch:
102	1	trace_step['in']['type'] = 'last'
103	1	trace_result.append(trace_step)
104	1	break
105	1	result = self.trace_step(switch, entries, stored_flows)
106	1	if result:
107	1	out = {'port': result['out_port']}
108	1	if 'dl_vlan' in result['entries']:
109	1	out.update({'vlan': result['entries']['dl_vlan'][-1]})
110	1	trace_step.update({
111		'out': out
112		})
113	1	if 'dpid' in result:
114	1	next_step = {'dpid': result['dpid'],
115		'port': result['in_port']}
116	1	entries = result['entries']
117	1	entries['dpid'] = result['dpid']
118	1	entries['in_port'] = result['in_port']
119	1	if self.has_loop(next_step, trace_result):
120	1	trace_step['in']['type'] = 'loop'
121	1	do_trace = False
122		else:
123	1	trace_type = 'intermediary'
124		else:
125	1	trace_step['in']['type'] = 'last'
126	1	do_trace = False
127		else:
128	1	trace_step['in']['type'] = 'incomplete'
129	1	do_trace = False
130	1	if 'out' in trace_step and trace_step['out']:
131	1	if self.check_loop_trace_step(trace_step, trace_result):
132	1	do_trace = False
133	1	trace_result.append(trace_step)
134	1	return trace_result
135
136	1	@staticmethod
137	1	def check_loop_trace_step(trace_step, trace_result):
138		"""Check if there is a loop in the trace and add the step."""
139		# outgoing interface is the same as the input interface
140	1	if not trace_result and \
141		trace_step['in']['type'] == 'last' and \
142		trace_step['in']['port'] == trace_step['out']['port']:
143	1	trace_step['in']['type'] = 'loop'
144	1	return True
145	1	if trace_result and \
146		trace_result[0]['in']['dpid'] == trace_step['in']['dpid'] and \
147		trace_result[0]['in']['port'] == trace_step['out']['port']:
148	1	trace_step['in']['type'] = 'loop'
149	1	return True
150	1	return False
151
152	1	@staticmethod
153	1	def has_loop(trace_step, trace_result):
154		"""Check if there is a loop in the trace result."""
155	1	for trace in trace_result:
156	1	if trace['in']['dpid'] == trace_step['dpid'] and \
157		trace['in']['port'] == trace_step['port']:
158	1	return True
159	1	return False
160
161	1	def trace_step(self, switch, entries, stored_flows):
162		"""Perform a trace step.
163
164		Match the given fields against the switch's list of flows."""
165	1	flow, entries, port = self.match_and_apply(
166		switch,
167		entries,
168		stored_flows
169		)
170
171	1	if not flow or not port:
172	1	return None
173
174	1	endpoint = find_endpoint(switch, port)
175	1	if endpoint is None:
176	1	return {'out_port': port,
177		'entries': entries}
178
179	1	return {'dpid': endpoint.switch.dpid,
180		'in_port': endpoint.port_number,
181		'out_port': port,
182		'entries': entries}
183
184	1	def update_circuits(self):
185		"""Update the list of circuits after a flow change."""
186		# pylint: disable=unused-argument
187	1	if settings.FIND_CIRCUITS_IN_FLOWS:
188	1	self.automate.find_circuits()
189
190	1	@classmethod
191	1	def do_match(cls, flow, args):
192		"""Match a packet against this flow (OF1.3)."""
193		# pylint: disable=consider-using-dict-items
194		# pylint: disable=too-many-return-statements
195	1	if ('match' not in flow['flow']) or (len(flow['flow']['match']) == 0):
196	1	return False
197	1	for name in flow['flow']['match']:
198	1	field_flow = flow['flow']['match'][name]
199	1	if name == 'dl_vlan':
200	1	field = args.get(name)
201	1	if field:
202	1	field = field[-1]
203	1	if not match_field_dl_vlan(field, field_flow):
204	1	return False
205		continue
206	1	if name not in args:
207		return False
208	1	field = args[name]
209	1	if name not in ('ipv4_src', 'ipv4_dst', 'ipv6_src', 'ipv6_dst'):
210	1	if field_flow != field:
211	1	return False
212		else:
213		packet_ip = int(ipaddress.ip_address(field))
214		ip_addr = flow['flow']['match'][name]
215		if packet_ip & ip_addr.netmask != ip_addr.address:
216		return False
217	1	return flow
218
219	1	def match_flows(self, switch, args, stored_flows, many=True):
220		# pylint: disable=bad-staticmethod-argument
221		"""
222		Match the packet in request against the stored flows from flow_manager.
223		Try the match with each flow, in other. If many is True, tries the
224		match with all flows, if False, tries until the first match.
225		:param args: packet data
226		:param many: Boolean, indicating whether to continue after matching the
227		first flow or not
228		:return: If many, the list of matched flows, or the matched flow
229		"""
230	1	if switch.dpid not in stored_flows:
231		return None
232	1	response = []
233	1	if switch.dpid not in stored_flows:
234		return None
235	1	try:
236	1	for flow in stored_flows[switch.dpid]:
237	1	match = Main.do_match(flow, args)
238	1	if match:
239	1	if many:
240		response.append(match)
241		else:
242	1	response = match
243	1	break
244		except AttributeError:
245		return None
246	1	if not many and isinstance(response, list):
247	1	return None
248	1	return response
249
250		# pylint: disable=redefined-outer-name
251	1	def match_and_apply(self, switch, args, stored_flows):
252		# pylint: disable=bad-staticmethod-argument
253		"""Match flows and apply actions.
254		Match given packet (in args) against
255		the stored flows (from flow_manager) and,
256		if a match flow is found, apply its actions."""
257	1	flow = self.match_flows(switch, args, stored_flows, False)
258	1	port = None
259	1	actions = []
260		# pylint: disable=too-many-nested-blocks
261	1	if not flow or switch.ofp_version != '0x04':
262	1	return flow, args, port
263	1	if 'actions' in flow['flow']:
264	1	actions = flow['flow']['actions']
265	1	for action in actions:
266	1	action_type = action['action_type']
267	1	if action_type == 'output':
268	1	port = action['port']
269	1	if action_type == 'push_vlan':
270	1	if 'dl_vlan' not in args:
271		args['dl_vlan'] = []
272	1	args['dl_vlan'].append(0)
273	1	if action_type == 'pop_vlan':
274	1	if 'dl_vlan' in args:
275	1	args['dl_vlan'].pop()
276	1	if len(args['dl_vlan']) == 0:
277	1	del args['dl_vlan']
278	1	if action_type == 'set_vlan':
279	1	args['dl_vlan'][-1] = action['vlan_id']
280		return flow, args, port
281

kytos-ng / sdntrace_cp

Pull Request — master (#90)

build.main.Main.has_loop() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like