Se reinstalo ryu para configurar STP y que el restAPI no sea publico(127.0.0.1)
[vsorcdistro/.git] / ryu / ryu / lib / ofctl_v1_3.py
1 # Copyright (C) 2013 Nippon Telegraph and Telephone Corporation.
2 #
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at
6 #
7 # http://www.apache.org/licenses/LICENSE-2.0
8 #
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
12 # implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
15
16 import base64
17 import logging
18
19 from ryu.ofproto import ether
20 from ryu.ofproto import inet
21 from ryu.ofproto import ofproto_common
22 from ryu.ofproto import ofproto_v1_3
23 from ryu.ofproto import ofproto_v1_3_parser
24 from ryu.lib import ofctl_nicira_ext
25 from ryu.lib import ofctl_utils
26
27
28 LOG = logging.getLogger('ryu.lib.ofctl_v1_3')
29
30 DEFAULT_TIMEOUT = 1.0
31
32 UTIL = ofctl_utils.OFCtlUtil(ofproto_v1_3)
33 str_to_int = ofctl_utils.str_to_int
34
35
36 def to_action(dp, dic):
37     ofp = dp.ofproto
38     parser = dp.ofproto_parser
39     action_type = dic.get('type')
40     return ofctl_utils.to_action(dic, ofp, parser, action_type, UTIL)
41
42
43 def to_actions(dp, acts):
44     inst = []
45     actions = []
46     ofp = dp.ofproto
47     parser = dp.ofproto_parser
48
49     for a in acts:
50         action = to_action(dp, a)
51
52         if action is not None:
53             actions.append(action)
54         else:
55             action_type = a.get('type')
56             if action_type == 'WRITE_ACTIONS':
57                 write_actions = []
58                 write_acts = a.get('actions')
59                 for act in write_acts:
60                     action = to_action(dp, act)
61                     if action is not None:
62                         write_actions.append(action)
63                     else:
64                         LOG.error('Unknown action type: %s', action_type)
65                 if write_actions:
66                     inst.append(
67                         parser.OFPInstructionActions(ofp.OFPIT_WRITE_ACTIONS,
68                                                      write_actions))
69             elif action_type == 'CLEAR_ACTIONS':
70                 inst.append(
71                     parser.OFPInstructionActions(ofp.OFPIT_CLEAR_ACTIONS, []))
72             elif action_type == 'GOTO_TABLE':
73                 table_id = UTIL.ofp_table_from_user(a.get('table_id'))
74                 inst.append(parser.OFPInstructionGotoTable(table_id))
75             elif action_type == 'WRITE_METADATA':
76                 metadata = str_to_int(a.get('metadata'))
77                 metadata_mask = (str_to_int(a['metadata_mask'])
78                                  if 'metadata_mask' in a
79                                  else parser.UINT64_MAX)
80                 inst.append(
81                     parser.OFPInstructionWriteMetadata(
82                         metadata, metadata_mask))
83             elif action_type == 'METER':
84                 meter_id = UTIL.ofp_meter_from_user(a.get('meter_id'))
85                 inst.append(parser.OFPInstructionMeter(meter_id))
86             else:
87                 LOG.error('Unknown action type: %s', action_type)
88
89     if actions:
90         inst.append(parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS,
91                                                  actions))
92     return inst
93
94
95 def action_to_str(act):
96     action_type = act.cls_action_type
97
98     if action_type == ofproto_v1_3.OFPAT_OUTPUT:
99         port = UTIL.ofp_port_to_user(act.port)
100         buf = 'OUTPUT:' + str(port)
101     elif action_type == ofproto_v1_3.OFPAT_COPY_TTL_OUT:
102         buf = 'COPY_TTL_OUT'
103     elif action_type == ofproto_v1_3.OFPAT_COPY_TTL_IN:
104         buf = 'COPY_TTL_IN'
105     elif action_type == ofproto_v1_3.OFPAT_SET_MPLS_TTL:
106         buf = 'SET_MPLS_TTL:' + str(act.mpls_ttl)
107     elif action_type == ofproto_v1_3.OFPAT_DEC_MPLS_TTL:
108         buf = 'DEC_MPLS_TTL'
109     elif action_type == ofproto_v1_3.OFPAT_PUSH_VLAN:
110         buf = 'PUSH_VLAN:' + str(act.ethertype)
111     elif action_type == ofproto_v1_3.OFPAT_POP_VLAN:
112         buf = 'POP_VLAN'
113     elif action_type == ofproto_v1_3.OFPAT_PUSH_MPLS:
114         buf = 'PUSH_MPLS:' + str(act.ethertype)
115     elif action_type == ofproto_v1_3.OFPAT_POP_MPLS:
116         buf = 'POP_MPLS:' + str(act.ethertype)
117     elif action_type == ofproto_v1_3.OFPAT_SET_QUEUE:
118         queue_id = UTIL.ofp_queue_to_user(act.queue_id)
119         buf = 'SET_QUEUE:' + str(queue_id)
120     elif action_type == ofproto_v1_3.OFPAT_GROUP:
121         group_id = UTIL.ofp_group_to_user(act.group_id)
122         buf = 'GROUP:' + str(group_id)
123     elif action_type == ofproto_v1_3.OFPAT_SET_NW_TTL:
124         buf = 'SET_NW_TTL:' + str(act.nw_ttl)
125     elif action_type == ofproto_v1_3.OFPAT_DEC_NW_TTL:
126         buf = 'DEC_NW_TTL'
127     elif action_type == ofproto_v1_3.OFPAT_SET_FIELD:
128         buf = 'SET_FIELD: {%s:%s}' % (act.key, act.value)
129     elif action_type == ofproto_v1_3.OFPAT_PUSH_PBB:
130         buf = 'PUSH_PBB:' + str(act.ethertype)
131     elif action_type == ofproto_v1_3.OFPAT_POP_PBB:
132         buf = 'POP_PBB'
133     elif action_type == ofproto_v1_3.OFPAT_EXPERIMENTER:
134         if act.experimenter == ofproto_common.NX_EXPERIMENTER_ID:
135             try:
136                 return ofctl_nicira_ext.action_to_str(act, action_to_str)
137             except Exception:
138                 LOG.debug('Error parsing NX_ACTION(%s)',
139                           act.__class__.__name__, exc_info=True)
140
141         data_str = base64.b64encode(act.data)
142         buf = 'EXPERIMENTER: {experimenter:%s, data:%s}' % \
143             (act.experimenter, data_str.decode('utf-8'))
144     else:
145         buf = 'UNKNOWN'
146     return buf
147
148
149 def actions_to_str(instructions):
150     actions = []
151
152     for instruction in instructions:
153         if isinstance(instruction,
154                       ofproto_v1_3_parser.OFPInstructionActions):
155             if instruction.type == ofproto_v1_3.OFPIT_APPLY_ACTIONS:
156                 for a in instruction.actions:
157                     actions.append(action_to_str(a))
158             elif instruction.type == ofproto_v1_3.OFPIT_WRITE_ACTIONS:
159                 write_actions = []
160                 for a in instruction.actions:
161                     write_actions.append(action_to_str(a))
162                 if write_actions:
163                     actions.append({'WRITE_ACTIONS': write_actions})
164             elif instruction.type == ofproto_v1_3.OFPIT_CLEAR_ACTIONS:
165                 actions.append('CLEAR_ACTIONS')
166             else:
167                 actions.append('UNKNOWN')
168         elif isinstance(instruction,
169                         ofproto_v1_3_parser.OFPInstructionGotoTable):
170             table_id = UTIL.ofp_table_to_user(instruction.table_id)
171             buf = 'GOTO_TABLE:' + str(table_id)
172             actions.append(buf)
173
174         elif isinstance(instruction,
175                         ofproto_v1_3_parser.OFPInstructionWriteMetadata):
176             buf = ('WRITE_METADATA:0x%x/0x%x' % (instruction.metadata,
177                                                  instruction.metadata_mask)
178                    if instruction.metadata_mask
179                    else 'WRITE_METADATA:0x%x' % instruction.metadata)
180             actions.append(buf)
181
182         elif isinstance(instruction,
183                         ofproto_v1_3_parser.OFPInstructionMeter):
184             meter_id = UTIL.ofp_meter_to_user(instruction.meter_id)
185             buf = 'METER:' + str(meter_id)
186             actions.append(buf)
187
188         else:
189             continue
190
191     return actions
192
193
194 def to_match(dp, attrs):
195     convert = {'in_port': UTIL.ofp_port_from_user,
196                'in_phy_port': str_to_int,
197                'metadata': ofctl_utils.to_match_masked_int,
198                'dl_dst': ofctl_utils.to_match_eth,
199                'dl_src': ofctl_utils.to_match_eth,
200                'eth_dst': ofctl_utils.to_match_eth,
201                'eth_src': ofctl_utils.to_match_eth,
202                'dl_type': str_to_int,
203                'eth_type': str_to_int,
204                'dl_vlan': to_match_vid,
205                'vlan_vid': to_match_vid,
206                'vlan_pcp': str_to_int,
207                'ip_dscp': str_to_int,
208                'ip_ecn': str_to_int,
209                'nw_proto': str_to_int,
210                'ip_proto': str_to_int,
211                'nw_src': ofctl_utils.to_match_ip,
212                'nw_dst': ofctl_utils.to_match_ip,
213                'ipv4_src': ofctl_utils.to_match_ip,
214                'ipv4_dst': ofctl_utils.to_match_ip,
215                'tp_src': str_to_int,
216                'tp_dst': str_to_int,
217                'tcp_src': str_to_int,
218                'tcp_dst': str_to_int,
219                'udp_src': str_to_int,
220                'udp_dst': str_to_int,
221                'sctp_src': str_to_int,
222                'sctp_dst': str_to_int,
223                'icmpv4_type': str_to_int,
224                'icmpv4_code': str_to_int,
225                'arp_op': str_to_int,
226                'arp_spa': ofctl_utils.to_match_ip,
227                'arp_tpa': ofctl_utils.to_match_ip,
228                'arp_sha': ofctl_utils.to_match_eth,
229                'arp_tha': ofctl_utils.to_match_eth,
230                'ipv6_src': ofctl_utils.to_match_ip,
231                'ipv6_dst': ofctl_utils.to_match_ip,
232                'ipv6_flabel': str_to_int,
233                'icmpv6_type': str_to_int,
234                'icmpv6_code': str_to_int,
235                'ipv6_nd_target': ofctl_utils.to_match_ip,
236                'ipv6_nd_sll': ofctl_utils.to_match_eth,
237                'ipv6_nd_tll': ofctl_utils.to_match_eth,
238                'mpls_label': str_to_int,
239                'mpls_tc': str_to_int,
240                'mpls_bos': str_to_int,
241                'pbb_isid': ofctl_utils.to_match_masked_int,
242                'tunnel_id': ofctl_utils.to_match_masked_int,
243                'ipv6_exthdr': ofctl_utils.to_match_masked_int}
244
245     keys = {'dl_dst': 'eth_dst',
246             'dl_src': 'eth_src',
247             'dl_type': 'eth_type',
248             'dl_vlan': 'vlan_vid',
249             'nw_src': 'ipv4_src',
250             'nw_dst': 'ipv4_dst',
251             'nw_proto': 'ip_proto'}
252
253     if attrs.get('dl_type') == ether.ETH_TYPE_ARP or \
254             attrs.get('eth_type') == ether.ETH_TYPE_ARP:
255         if 'nw_src' in attrs and 'arp_spa' not in attrs:
256             attrs['arp_spa'] = attrs['nw_src']
257             del attrs['nw_src']
258         if 'nw_dst' in attrs and 'arp_tpa' not in attrs:
259             attrs['arp_tpa'] = attrs['nw_dst']
260             del attrs['nw_dst']
261
262     kwargs = {}
263     for key, value in attrs.items():
264         if key in keys:
265             # For old field name
266             key = keys[key]
267         if key in convert:
268             value = convert[key](value)
269             if key == 'tp_src' or key == 'tp_dst':
270                 # TCP/UDP port
271                 conv = {inet.IPPROTO_TCP: {'tp_src': 'tcp_src',
272                                            'tp_dst': 'tcp_dst'},
273                         inet.IPPROTO_UDP: {'tp_src': 'udp_src',
274                                            'tp_dst': 'udp_dst'}}
275                 ip_proto = attrs.get('nw_proto', attrs.get('ip_proto', 0))
276                 key = conv[ip_proto][key]
277                 kwargs[key] = value
278             else:
279                 # others
280                 kwargs[key] = value
281         else:
282             LOG.error('Unknown match field: %s', key)
283
284     return dp.ofproto_parser.OFPMatch(**kwargs)
285
286
287 def to_match_vid(value):
288     return ofctl_utils.to_match_vid(value, ofproto_v1_3.OFPVID_PRESENT)
289
290
291 def match_to_str(ofmatch):
292
293     keys = {'eth_src': 'dl_src',
294             'eth_dst': 'dl_dst',
295             'eth_type': 'dl_type',
296             'vlan_vid': 'dl_vlan',
297             'ipv4_src': 'nw_src',
298             'ipv4_dst': 'nw_dst',
299             'ip_proto': 'nw_proto',
300             'tcp_src': 'tp_src',
301             'tcp_dst': 'tp_dst',
302             'udp_src': 'tp_src',
303             'udp_dst': 'tp_dst'}
304
305     match = {}
306
307     ofmatch = ofmatch.to_jsondict()['OFPMatch']
308     ofmatch = ofmatch['oxm_fields']
309
310     for match_field in ofmatch:
311         key = match_field['OXMTlv']['field']
312         if key in keys:
313             key = keys[key]
314         mask = match_field['OXMTlv']['mask']
315         value = match_field['OXMTlv']['value']
316         if key == 'dl_vlan':
317             value = match_vid_to_str(value, mask)
318         elif key == 'in_port':
319             value = UTIL.ofp_port_to_user(value)
320         else:
321             if mask is not None:
322                 value = str(value) + '/' + str(mask)
323         match.setdefault(key, value)
324
325     return match
326
327
328 def match_vid_to_str(value, mask):
329     return ofctl_utils.match_vid_to_str(
330         value, mask, ofproto_v1_3.OFPVID_PRESENT)
331
332
333 def wrap_dpid_dict(dp, value, to_user=True):
334     if to_user:
335         return {str(dp.id): value}
336
337     return {dp.id: value}
338
339
340 def get_desc_stats(dp, waiters, to_user=True):
341     stats = dp.ofproto_parser.OFPDescStatsRequest(dp, 0)
342     msgs = []
343     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
344     s = {}
345
346     for msg in msgs:
347         stats = msg.body
348         s = stats.to_jsondict()[stats.__class__.__name__]
349
350     return wrap_dpid_dict(dp, s, to_user)
351
352
353 def get_queue_stats(dp, waiters, port=None, queue_id=None, to_user=True):
354     ofp = dp.ofproto
355
356     if port is None:
357         port = ofp.OFPP_ANY
358     else:
359         port = str_to_int(port)
360
361     if queue_id is None:
362         queue_id = ofp.OFPQ_ALL
363     else:
364         queue_id = str_to_int(queue_id)
365
366     stats = dp.ofproto_parser.OFPQueueStatsRequest(dp, 0, port,
367                                                    queue_id)
368     msgs = []
369     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
370
371     s = []
372     for msg in msgs:
373         stats = msg.body
374         for stat in stats:
375             s.append({'duration_nsec': stat.duration_nsec,
376                       'duration_sec': stat.duration_sec,
377                       'port_no': stat.port_no,
378                       'queue_id': stat.queue_id,
379                       'tx_bytes': stat.tx_bytes,
380                       'tx_errors': stat.tx_errors,
381                       'tx_packets': stat.tx_packets})
382
383     return wrap_dpid_dict(dp, s, to_user)
384
385
386 def get_queue_config(dp, waiters, port=None, to_user=True):
387     ofp = dp.ofproto
388     if port is None:
389         port = ofp.OFPP_ANY
390     else:
391         port = UTIL.ofp_port_from_user(str_to_int(port))
392     stats = dp.ofproto_parser.OFPQueueGetConfigRequest(dp, port)
393     msgs = []
394     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
395
396     prop_type = {dp.ofproto.OFPQT_MIN_RATE: 'MIN_RATE',
397                  dp.ofproto.OFPQT_MAX_RATE: 'MAX_RATE',
398                  dp.ofproto.OFPQT_EXPERIMENTER: 'EXPERIMENTER'}
399
400     configs = []
401     for config in msgs:
402         queue_list = []
403         for queue in config.queues:
404             prop_list = []
405             for prop in queue.properties:
406                 p = {'property': prop_type.get(prop.property, 'UNKNOWN')}
407                 if prop.property == dp.ofproto.OFPQT_MIN_RATE or \
408                    prop.property == dp.ofproto.OFPQT_MAX_RATE:
409                     p['rate'] = prop.rate
410                 elif prop.property == dp.ofproto.OFPQT_EXPERIMENTER:
411                     p['experimenter'] = prop.experimenter
412                     p['data'] = prop.data
413                 prop_list.append(p)
414
415             q = {'properties': prop_list}
416
417             if to_user:
418                 q['port'] = UTIL.ofp_port_to_user(queue.port)
419                 q['queue_id'] = UTIL.ofp_queue_to_user(queue.queue_id)
420
421             else:
422                 q['port'] = queue.port
423                 q['queue_id'] = queue.queue_id
424
425             queue_list.append(q)
426
427         c = {'queues': queue_list}
428
429         if to_user:
430             c['port'] = UTIL.ofp_port_to_user(config.port)
431
432         else:
433             c['port'] = config.port
434
435         configs.append(c)
436
437     return wrap_dpid_dict(dp, configs, to_user)
438
439
440 def get_flow_stats(dp, waiters, flow=None, to_user=True):
441     flow = flow if flow else {}
442     table_id = UTIL.ofp_table_from_user(
443         flow.get('table_id', dp.ofproto.OFPTT_ALL))
444     flags = str_to_int(flow.get('flags', 0))
445     out_port = UTIL.ofp_port_from_user(
446         flow.get('out_port', dp.ofproto.OFPP_ANY))
447     out_group = UTIL.ofp_group_from_user(
448         flow.get('out_group', dp.ofproto.OFPG_ANY))
449     cookie = str_to_int(flow.get('cookie', 0))
450     cookie_mask = str_to_int(flow.get('cookie_mask', 0))
451     match = to_match(dp, flow.get('match', {}))
452     # Note: OpenFlow does not allow to filter flow entries by priority,
453     # but for efficiency, ofctl provides the way to do it.
454     priority = str_to_int(flow.get('priority', -1))
455
456     stats = dp.ofproto_parser.OFPFlowStatsRequest(
457         dp, flags, table_id, out_port, out_group, cookie, cookie_mask,
458         match)
459
460     msgs = []
461     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
462
463     flows = []
464     for msg in msgs:
465         for stats in msg.body:
466             if 0 <= priority != stats.priority:
467                 continue
468
469             s = {'priority': stats.priority,
470                  'cookie': stats.cookie,
471                  'idle_timeout': stats.idle_timeout,
472                  'hard_timeout': stats.hard_timeout,
473                  'byte_count': stats.byte_count,
474                  'duration_sec': stats.duration_sec,
475                  'duration_nsec': stats.duration_nsec,
476                  'packet_count': stats.packet_count,
477                  'length': stats.length,
478                  'flags': stats.flags}
479
480             if to_user:
481                 s['actions'] = actions_to_str(stats.instructions)
482                 s['match'] = match_to_str(stats.match)
483                 s['table_id'] = UTIL.ofp_table_to_user(stats.table_id)
484
485             else:
486                 s['actions'] = stats.instructions
487                 s['instructions'] = stats.instructions
488                 s['match'] = stats.match
489                 s['table_id'] = stats.table_id
490
491             flows.append(s)
492
493     return wrap_dpid_dict(dp, flows, to_user)
494
495
496 def get_aggregate_flow_stats(dp, waiters, flow=None, to_user=True):
497     flow = flow if flow else {}
498     table_id = UTIL.ofp_table_from_user(
499         flow.get('table_id', dp.ofproto.OFPTT_ALL))
500     flags = str_to_int(flow.get('flags', 0))
501     out_port = UTIL.ofp_port_from_user(
502         flow.get('out_port', dp.ofproto.OFPP_ANY))
503     out_group = UTIL.ofp_group_from_user(
504         flow.get('out_group', dp.ofproto.OFPG_ANY))
505     cookie = str_to_int(flow.get('cookie', 0))
506     cookie_mask = str_to_int(flow.get('cookie_mask', 0))
507     match = to_match(dp, flow.get('match', {}))
508
509     stats = dp.ofproto_parser.OFPAggregateStatsRequest(
510         dp, flags, table_id, out_port, out_group, cookie, cookie_mask,
511         match)
512
513     msgs = []
514     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
515
516     flows = []
517     for msg in msgs:
518         stats = msg.body
519         s = {'packet_count': stats.packet_count,
520              'byte_count': stats.byte_count,
521              'flow_count': stats.flow_count}
522         flows.append(s)
523
524     return wrap_dpid_dict(dp, flows, to_user)
525
526
527 def get_table_stats(dp, waiters, to_user=True):
528     stats = dp.ofproto_parser.OFPTableStatsRequest(dp, 0)
529     msgs = []
530     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
531
532     tables = []
533     for msg in msgs:
534         stats = msg.body
535         for stat in stats:
536             s = {'active_count': stat.active_count,
537                  'lookup_count': stat.lookup_count,
538                  'matched_count': stat.matched_count}
539
540             if to_user:
541                 s['table_id'] = UTIL.ofp_table_to_user(stat.table_id)
542
543             else:
544                 s['table_id'] = stat.table_id
545
546             tables.append(s)
547
548     return wrap_dpid_dict(dp, tables, to_user)
549
550
551 def get_table_features(dp, waiters, to_user=True):
552     stats = dp.ofproto_parser.OFPTableFeaturesStatsRequest(dp, 0, [])
553     msgs = []
554     ofproto = dp.ofproto
555     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
556
557     prop_type = {ofproto.OFPTFPT_INSTRUCTIONS: 'INSTRUCTIONS',
558                  ofproto.OFPTFPT_INSTRUCTIONS_MISS: 'INSTRUCTIONS_MISS',
559                  ofproto.OFPTFPT_NEXT_TABLES: 'NEXT_TABLES',
560                  ofproto.OFPTFPT_NEXT_TABLES_MISS: 'NEXT_TABLES_MISS',
561                  ofproto.OFPTFPT_WRITE_ACTIONS: 'WRITE_ACTIONS',
562                  ofproto.OFPTFPT_WRITE_ACTIONS_MISS: 'WRITE_ACTIONS_MISS',
563                  ofproto.OFPTFPT_APPLY_ACTIONS: 'APPLY_ACTIONS',
564                  ofproto.OFPTFPT_APPLY_ACTIONS_MISS: 'APPLY_ACTIONS_MISS',
565                  ofproto.OFPTFPT_MATCH: 'MATCH',
566                  ofproto.OFPTFPT_WILDCARDS: 'WILDCARDS',
567                  ofproto.OFPTFPT_WRITE_SETFIELD: 'WRITE_SETFIELD',
568                  ofproto.OFPTFPT_WRITE_SETFIELD_MISS: 'WRITE_SETFIELD_MISS',
569                  ofproto.OFPTFPT_APPLY_SETFIELD: 'APPLY_SETFIELD',
570                  ofproto.OFPTFPT_APPLY_SETFIELD_MISS: 'APPLY_SETFIELD_MISS',
571                  ofproto.OFPTFPT_EXPERIMENTER: 'EXPERIMENTER',
572                  ofproto.OFPTFPT_EXPERIMENTER_MISS: 'EXPERIMENTER_MISS'}
573
574     if not to_user:
575         prop_type = dict((k, k) for k in prop_type.keys())
576
577     p_type_instructions = [ofproto.OFPTFPT_INSTRUCTIONS,
578                            ofproto.OFPTFPT_INSTRUCTIONS_MISS]
579
580     p_type_next_tables = [ofproto.OFPTFPT_NEXT_TABLES,
581                           ofproto.OFPTFPT_NEXT_TABLES_MISS]
582
583     p_type_actions = [ofproto.OFPTFPT_WRITE_ACTIONS,
584                       ofproto.OFPTFPT_WRITE_ACTIONS_MISS,
585                       ofproto.OFPTFPT_APPLY_ACTIONS,
586                       ofproto.OFPTFPT_APPLY_ACTIONS_MISS]
587
588     p_type_oxms = [ofproto.OFPTFPT_MATCH,
589                    ofproto.OFPTFPT_WILDCARDS,
590                    ofproto.OFPTFPT_WRITE_SETFIELD,
591                    ofproto.OFPTFPT_WRITE_SETFIELD_MISS,
592                    ofproto.OFPTFPT_APPLY_SETFIELD,
593                    ofproto.OFPTFPT_APPLY_SETFIELD_MISS]
594
595     p_type_experimenter = [ofproto.OFPTFPT_EXPERIMENTER,
596                            ofproto.OFPTFPT_EXPERIMENTER_MISS]
597
598     tables = []
599     for msg in msgs:
600         stats = msg.body
601         for stat in stats:
602             properties = []
603             for prop in stat.properties:
604                 p = {'type': prop_type.get(prop.type, 'UNKNOWN')}
605                 if prop.type in p_type_instructions:
606                     instruction_ids = []
607                     for i in prop.instruction_ids:
608                         inst = {'len': i.len,
609                                 'type': i.type}
610                         instruction_ids.append(inst)
611                     p['instruction_ids'] = instruction_ids
612                 elif prop.type in p_type_next_tables:
613                     table_ids = []
614                     for i in prop.table_ids:
615                         table_ids.append(i)
616                     p['table_ids'] = table_ids
617                 elif prop.type in p_type_actions:
618                     action_ids = []
619                     for i in prop.action_ids:
620                         act = {'len': i.len,
621                                'type': i.type}
622                         action_ids.append(act)
623                     p['action_ids'] = action_ids
624                 elif prop.type in p_type_oxms:
625                     oxm_ids = []
626                     for i in prop.oxm_ids:
627                         oxm = {'hasmask': i.hasmask,
628                                'length': i.length,
629                                'type': i.type}
630                         oxm_ids.append(oxm)
631                     p['oxm_ids'] = oxm_ids
632                 elif prop.type in p_type_experimenter:
633                     pass
634                 properties.append(p)
635             s = {
636                 'name': stat.name.decode('utf-8'),
637                 'metadata_match': stat.metadata_match,
638                 'metadata_write': stat.metadata_write,
639                 'config': stat.config,
640                 'max_entries': stat.max_entries,
641                 'properties': properties,
642             }
643
644             if to_user:
645                 s['table_id'] = UTIL.ofp_table_to_user(stat.table_id)
646
647             else:
648                 s['table_id'] = stat.table_id
649
650             tables.append(s)
651
652     return wrap_dpid_dict(dp, tables, to_user)
653
654
655 def get_port_stats(dp, waiters, port=None, to_user=True):
656     if port is None:
657         port = dp.ofproto.OFPP_ANY
658     else:
659         port = str_to_int(port)
660
661     stats = dp.ofproto_parser.OFPPortStatsRequest(
662         dp, 0, port)
663     msgs = []
664     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
665
666     ports = []
667     for msg in msgs:
668         for stats in msg.body:
669             s = {'rx_packets': stats.rx_packets,
670                  'tx_packets': stats.tx_packets,
671                  'rx_bytes': stats.rx_bytes,
672                  'tx_bytes': stats.tx_bytes,
673                  'rx_dropped': stats.rx_dropped,
674                  'tx_dropped': stats.tx_dropped,
675                  'rx_errors': stats.rx_errors,
676                  'tx_errors': stats.tx_errors,
677                  'rx_frame_err': stats.rx_frame_err,
678                  'rx_over_err': stats.rx_over_err,
679                  'rx_crc_err': stats.rx_crc_err,
680                  'collisions': stats.collisions,
681                  'duration_sec': stats.duration_sec,
682                  'duration_nsec': stats.duration_nsec}
683
684             if to_user:
685                 s['port_no'] = UTIL.ofp_port_to_user(stats.port_no)
686
687             else:
688                 s['port_no'] = stats.port_no
689
690             ports.append(s)
691
692     return wrap_dpid_dict(dp, ports, to_user)
693
694
695 def get_meter_stats(dp, waiters, meter_id=None, to_user=True):
696     if meter_id is None:
697         meter_id = dp.ofproto.OFPM_ALL
698     else:
699         meter_id = str_to_int(meter_id)
700
701     stats = dp.ofproto_parser.OFPMeterStatsRequest(
702         dp, 0, meter_id)
703     msgs = []
704     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
705
706     meters = []
707     for msg in msgs:
708         for stats in msg.body:
709             bands = []
710             for band in stats.band_stats:
711                 b = {'packet_band_count': band.packet_band_count,
712                      'byte_band_count': band.byte_band_count}
713                 bands.append(b)
714             s = {'len': stats.len,
715                  'flow_count': stats.flow_count,
716                  'packet_in_count': stats.packet_in_count,
717                  'byte_in_count': stats.byte_in_count,
718                  'duration_sec': stats.duration_sec,
719                  'duration_nsec': stats.duration_nsec,
720                  'band_stats': bands}
721
722             if to_user:
723                 s['meter_id'] = UTIL.ofp_meter_to_user(stats.meter_id)
724
725             else:
726                 s['meter_id'] = stats.meter_id
727
728             meters.append(s)
729
730     return wrap_dpid_dict(dp, meters, to_user)
731
732
733 def get_meter_features(dp, waiters, to_user=True):
734
735     ofp = dp.ofproto
736     type_convert = {ofp.OFPMBT_DROP: 'DROP',
737                     ofp.OFPMBT_DSCP_REMARK: 'DSCP_REMARK'}
738
739     capa_convert = {ofp.OFPMF_KBPS: 'KBPS',
740                     ofp.OFPMF_PKTPS: 'PKTPS',
741                     ofp.OFPMF_BURST: 'BURST',
742                     ofp.OFPMF_STATS: 'STATS'}
743
744     stats = dp.ofproto_parser.OFPMeterFeaturesStatsRequest(dp, 0)
745     msgs = []
746     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
747
748     features = []
749     for msg in msgs:
750         for feature in msg.body:
751             band_types = []
752             for k, v in type_convert.items():
753                 if (1 << k) & feature.band_types:
754
755                     if to_user:
756                         band_types.append(v)
757
758                     else:
759                         band_types.append(k)
760
761             capabilities = []
762             for k, v in sorted(capa_convert.items()):
763                 if k & feature.capabilities:
764
765                     if to_user:
766                         capabilities.append(v)
767
768                     else:
769                         capabilities.append(k)
770
771             f = {'max_meter': feature.max_meter,
772                  'band_types': band_types,
773                  'capabilities': capabilities,
774                  'max_bands': feature.max_bands,
775                  'max_color': feature.max_color}
776             features.append(f)
777
778     return wrap_dpid_dict(dp, features, to_user)
779
780
781 def get_meter_config(dp, waiters, meter_id=None, to_user=True):
782     flags = {dp.ofproto.OFPMF_KBPS: 'KBPS',
783              dp.ofproto.OFPMF_PKTPS: 'PKTPS',
784              dp.ofproto.OFPMF_BURST: 'BURST',
785              dp.ofproto.OFPMF_STATS: 'STATS'}
786
787     band_type = {dp.ofproto.OFPMBT_DROP: 'DROP',
788                  dp.ofproto.OFPMBT_DSCP_REMARK: 'DSCP_REMARK',
789                  dp.ofproto.OFPMBT_EXPERIMENTER: 'EXPERIMENTER'}
790
791     if meter_id is None:
792         meter_id = dp.ofproto.OFPM_ALL
793     else:
794         meter_id = str_to_int(meter_id)
795
796     stats = dp.ofproto_parser.OFPMeterConfigStatsRequest(
797         dp, 0, meter_id)
798     msgs = []
799     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
800
801     configs = []
802     for msg in msgs:
803         for config in msg.body:
804             bands = []
805             for band in config.bands:
806                 b = {'rate': band.rate,
807                      'burst_size': band.burst_size}
808
809                 if to_user:
810                     b['type'] = band_type.get(band.type, '')
811
812                 else:
813                     b['type'] = band.type
814
815                 if band.type == dp.ofproto.OFPMBT_DSCP_REMARK:
816                     b['prec_level'] = band.prec_level
817                 elif band.type == dp.ofproto.OFPMBT_EXPERIMENTER:
818                     b['experimenter'] = band.experimenter
819                 bands.append(b)
820             c_flags = []
821             for k, v in sorted(flags.items()):
822                 if k & config.flags:
823                     if to_user:
824                         c_flags.append(v)
825
826                     else:
827                         c_flags.append(k)
828
829             c = {'flags': c_flags,
830                  'bands': bands}
831
832             if to_user:
833                 c['meter_id'] = UTIL.ofp_meter_to_user(config.meter_id)
834
835             else:
836                 c['meter_id'] = config.meter_id
837
838             configs.append(c)
839
840     return wrap_dpid_dict(dp, configs, to_user)
841
842
843 def get_group_stats(dp, waiters, group_id=None, to_user=True):
844     if group_id is None:
845         group_id = dp.ofproto.OFPG_ALL
846     else:
847         group_id = str_to_int(group_id)
848
849     stats = dp.ofproto_parser.OFPGroupStatsRequest(
850         dp, 0, group_id)
851     msgs = []
852     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
853
854     groups = []
855     for msg in msgs:
856         for stats in msg.body:
857             bucket_stats = []
858             for bucket_stat in stats.bucket_stats:
859                 c = {'packet_count': bucket_stat.packet_count,
860                      'byte_count': bucket_stat.byte_count}
861                 bucket_stats.append(c)
862             g = {'length': stats.length,
863                  'ref_count': stats.ref_count,
864                  'packet_count': stats.packet_count,
865                  'byte_count': stats.byte_count,
866                  'duration_sec': stats.duration_sec,
867                  'duration_nsec': stats.duration_nsec,
868                  'bucket_stats': bucket_stats}
869
870             if to_user:
871                 g['group_id'] = UTIL.ofp_group_to_user(stats.group_id)
872
873             else:
874                 g['group_id'] = stats.group_id
875
876             groups.append(g)
877
878     return wrap_dpid_dict(dp, groups, to_user)
879
880
881 def get_group_features(dp, waiters, to_user=True):
882
883     ofp = dp.ofproto
884     type_convert = {ofp.OFPGT_ALL: 'ALL',
885                     ofp.OFPGT_SELECT: 'SELECT',
886                     ofp.OFPGT_INDIRECT: 'INDIRECT',
887                     ofp.OFPGT_FF: 'FF'}
888     cap_convert = {ofp.OFPGFC_SELECT_WEIGHT: 'SELECT_WEIGHT',
889                    ofp.OFPGFC_SELECT_LIVENESS: 'SELECT_LIVENESS',
890                    ofp.OFPGFC_CHAINING: 'CHAINING',
891                    ofp.OFPGFC_CHAINING_CHECKS: 'CHAINING_CHECKS'}
892     act_convert = {ofp.OFPAT_OUTPUT: 'OUTPUT',
893                    ofp.OFPAT_COPY_TTL_OUT: 'COPY_TTL_OUT',
894                    ofp.OFPAT_COPY_TTL_IN: 'COPY_TTL_IN',
895                    ofp.OFPAT_SET_MPLS_TTL: 'SET_MPLS_TTL',
896                    ofp.OFPAT_DEC_MPLS_TTL: 'DEC_MPLS_TTL',
897                    ofp.OFPAT_PUSH_VLAN: 'PUSH_VLAN',
898                    ofp.OFPAT_POP_VLAN: 'POP_VLAN',
899                    ofp.OFPAT_PUSH_MPLS: 'PUSH_MPLS',
900                    ofp.OFPAT_POP_MPLS: 'POP_MPLS',
901                    ofp.OFPAT_SET_QUEUE: 'SET_QUEUE',
902                    ofp.OFPAT_GROUP: 'GROUP',
903                    ofp.OFPAT_SET_NW_TTL: 'SET_NW_TTL',
904                    ofp.OFPAT_DEC_NW_TTL: 'DEC_NW_TTL',
905                    ofp.OFPAT_SET_FIELD: 'SET_FIELD',
906                    ofp.OFPAT_PUSH_PBB: 'PUSH_PBB',
907                    ofp.OFPAT_POP_PBB: 'POP_PBB'}
908
909     stats = dp.ofproto_parser.OFPGroupFeaturesStatsRequest(dp, 0)
910     msgs = []
911     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
912
913     features = []
914     for msg in msgs:
915         feature = msg.body
916         types = []
917         for k, v in type_convert.items():
918             if (1 << k) & feature.types:
919                 if to_user:
920                     types.append(v)
921
922                 else:
923                     types.append(k)
924
925         capabilities = []
926         for k, v in cap_convert.items():
927             if k & feature.capabilities:
928                 if to_user:
929                     capabilities.append(v)
930
931                 else:
932                     capabilities.append(k)
933
934         if to_user:
935             max_groups = []
936             for k, v in type_convert.items():
937                 max_groups.append({v: feature.max_groups[k]})
938
939         else:
940             max_groups = feature.max_groups
941
942         actions = []
943         for k1, v1 in type_convert.items():
944             acts = []
945             for k2, v2 in act_convert.items():
946                 if (1 << k2) & feature.actions[k1]:
947                     if to_user:
948                         acts.append(v2)
949
950                     else:
951                         acts.append(k2)
952
953             if to_user:
954                 actions.append({v1: acts})
955
956             else:
957                 actions.append({k1: acts})
958
959         f = {'types': types,
960              'capabilities': capabilities,
961              'max_groups': max_groups,
962              'actions': actions}
963         features.append(f)
964
965     return wrap_dpid_dict(dp, features, to_user)
966
967
968 def get_group_desc(dp, waiters, to_user=True):
969
970     type_convert = {dp.ofproto.OFPGT_ALL: 'ALL',
971                     dp.ofproto.OFPGT_SELECT: 'SELECT',
972                     dp.ofproto.OFPGT_INDIRECT: 'INDIRECT',
973                     dp.ofproto.OFPGT_FF: 'FF'}
974
975     stats = dp.ofproto_parser.OFPGroupDescStatsRequest(dp, 0)
976     msgs = []
977     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
978
979     descs = []
980     for msg in msgs:
981         for stats in msg.body:
982             buckets = []
983             for bucket in stats.buckets:
984                 actions = []
985                 for action in bucket.actions:
986                     if to_user:
987                         actions.append(action_to_str(action))
988
989                     else:
990                         actions.append(action)
991
992                 b = {'weight': bucket.weight,
993                      'watch_port': bucket.watch_port,
994                      'watch_group': bucket.watch_group,
995                      'actions': actions}
996                 buckets.append(b)
997
998             d = {'buckets': buckets}
999             if to_user:
1000                 d['group_id'] = UTIL.ofp_group_to_user(stats.group_id)
1001                 d['type'] = type_convert.get(stats.type)
1002
1003             else:
1004                 d['group_id'] = stats.group_id
1005                 d['type'] = stats.type
1006
1007             descs.append(d)
1008
1009     return wrap_dpid_dict(dp, descs, to_user)
1010
1011
1012 def get_port_desc(dp, waiters, to_user=True):
1013
1014     stats = dp.ofproto_parser.OFPPortDescStatsRequest(dp, 0)
1015     msgs = []
1016     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
1017
1018     descs = []
1019
1020     for msg in msgs:
1021         stats = msg.body
1022         for stat in stats:
1023             d = {'hw_addr': stat.hw_addr,
1024                  'name': stat.name.decode('utf-8', errors='replace'),
1025                  'config': stat.config,
1026                  'state': stat.state,
1027                  'curr': stat.curr,
1028                  'advertised': stat.advertised,
1029                  'supported': stat.supported,
1030                  'peer': stat.peer,
1031                  'curr_speed': stat.curr_speed,
1032                  'max_speed': stat.max_speed}
1033
1034             if to_user:
1035                 d['port_no'] = UTIL.ofp_port_to_user(stat.port_no)
1036
1037             else:
1038                 d['port_no'] = stat.port_no
1039
1040             descs.append(d)
1041
1042     return wrap_dpid_dict(dp, descs, to_user)
1043
1044
1045 def get_role(dp, waiters, to_user=True):
1046     return ofctl_utils.get_role(dp, waiters, to_user)
1047
1048
1049 def mod_flow_entry(dp, flow, cmd):
1050     cookie = str_to_int(flow.get('cookie', 0))
1051     cookie_mask = str_to_int(flow.get('cookie_mask', 0))
1052     table_id = UTIL.ofp_table_from_user(flow.get('table_id', 0))
1053     idle_timeout = str_to_int(flow.get('idle_timeout', 0))
1054     hard_timeout = str_to_int(flow.get('hard_timeout', 0))
1055     priority = str_to_int(flow.get('priority', 0))
1056     buffer_id = UTIL.ofp_buffer_from_user(
1057         flow.get('buffer_id', dp.ofproto.OFP_NO_BUFFER))
1058     out_port = UTIL.ofp_port_from_user(
1059         flow.get('out_port', dp.ofproto.OFPP_ANY))
1060     out_group = UTIL.ofp_group_from_user(
1061         flow.get('out_group', dp.ofproto.OFPG_ANY))
1062     flags = str_to_int(flow.get('flags', 0))
1063     match = to_match(dp, flow.get('match', {}))
1064     inst = to_actions(dp, flow.get('actions', []))
1065
1066     flow_mod = dp.ofproto_parser.OFPFlowMod(
1067         dp, cookie, cookie_mask, table_id, cmd, idle_timeout,
1068         hard_timeout, priority, buffer_id, out_port, out_group,
1069         flags, match, inst)
1070
1071     ofctl_utils.send_msg(dp, flow_mod, LOG)
1072
1073
1074 def mod_meter_entry(dp, meter, cmd):
1075
1076     flags_convert = {'KBPS': dp.ofproto.OFPMF_KBPS,
1077                      'PKTPS': dp.ofproto.OFPMF_PKTPS,
1078                      'BURST': dp.ofproto.OFPMF_BURST,
1079                      'STATS': dp.ofproto.OFPMF_STATS}
1080
1081     flags = 0
1082     if 'flags' in meter:
1083         meter_flags = meter['flags']
1084         if not isinstance(meter_flags, list):
1085             meter_flags = [meter_flags]
1086         for flag in meter_flags:
1087             if flag not in flags_convert:
1088                 LOG.error('Unknown meter flag: %s', flag)
1089                 continue
1090             flags |= flags_convert.get(flag)
1091
1092     meter_id = UTIL.ofp_meter_from_user(meter.get('meter_id', 0))
1093
1094     bands = []
1095     for band in meter.get('bands', []):
1096         band_type = band.get('type')
1097         rate = str_to_int(band.get('rate', 0))
1098         burst_size = str_to_int(band.get('burst_size', 0))
1099         if band_type == 'DROP':
1100             bands.append(
1101                 dp.ofproto_parser.OFPMeterBandDrop(rate, burst_size))
1102         elif band_type == 'DSCP_REMARK':
1103             prec_level = str_to_int(band.get('prec_level', 0))
1104             bands.append(
1105                 dp.ofproto_parser.OFPMeterBandDscpRemark(
1106                     rate, burst_size, prec_level))
1107         elif band_type == 'EXPERIMENTER':
1108             experimenter = str_to_int(band.get('experimenter', 0))
1109             bands.append(
1110                 dp.ofproto_parser.OFPMeterBandExperimenter(
1111                     rate, burst_size, experimenter))
1112         else:
1113             LOG.error('Unknown band type: %s', band_type)
1114
1115     meter_mod = dp.ofproto_parser.OFPMeterMod(
1116         dp, cmd, flags, meter_id, bands)
1117
1118     ofctl_utils.send_msg(dp, meter_mod, LOG)
1119
1120
1121 def mod_group_entry(dp, group, cmd):
1122
1123     type_convert = {'ALL': dp.ofproto.OFPGT_ALL,
1124                     'SELECT': dp.ofproto.OFPGT_SELECT,
1125                     'INDIRECT': dp.ofproto.OFPGT_INDIRECT,
1126                     'FF': dp.ofproto.OFPGT_FF}
1127
1128     type_ = type_convert.get(group.get('type', 'ALL'))
1129     if type_ is None:
1130         LOG.error('Unknown group type: %s', group.get('type'))
1131
1132     group_id = UTIL.ofp_group_from_user(group.get('group_id', 0))
1133
1134     buckets = []
1135     for bucket in group.get('buckets', []):
1136         weight = str_to_int(bucket.get('weight', 0))
1137         watch_port = str_to_int(
1138             bucket.get('watch_port', dp.ofproto.OFPP_ANY))
1139         watch_group = str_to_int(
1140             bucket.get('watch_group', dp.ofproto.OFPG_ANY))
1141         actions = []
1142         for dic in bucket.get('actions', []):
1143             action = to_action(dp, dic)
1144             if action is not None:
1145                 actions.append(action)
1146         buckets.append(dp.ofproto_parser.OFPBucket(
1147             weight, watch_port, watch_group, actions))
1148
1149     group_mod = dp.ofproto_parser.OFPGroupMod(
1150         dp, cmd, type_, group_id, buckets)
1151
1152     ofctl_utils.send_msg(dp, group_mod, LOG)
1153
1154
1155 def mod_port_behavior(dp, port_config):
1156     port_no = UTIL.ofp_port_from_user(port_config.get('port_no', 0))
1157     hw_addr = str(port_config.get('hw_addr'))
1158     config = str_to_int(port_config.get('config', 0))
1159     mask = str_to_int(port_config.get('mask', 0))
1160     advertise = str_to_int(port_config.get('advertise'))
1161
1162     port_mod = dp.ofproto_parser.OFPPortMod(
1163         dp, port_no, hw_addr, config, mask, advertise)
1164
1165     ofctl_utils.send_msg(dp, port_mod, LOG)
1166
1167
1168 def set_role(dp, role):
1169     r = UTIL.ofp_role_from_user(role.get('role', dp.ofproto.OFPCR_ROLE_EQUAL))
1170     role_request = dp.ofproto_parser.OFPRoleRequest(dp, r, 0)
1171     ofctl_utils.send_msg(dp, role_request, LOG)
1172
1173
1174 # NOTE(jkoelker) Alias common funcitons
1175 send_experimenter = ofctl_utils.send_experimenter