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