Se reinstalo ryu para configurar STP y que el restAPI no sea publico(127.0.0.1)
[vsorcdistro/.git] / ryu / ryu / lib / ofctl_v1_4.py
1 # Copyright (C) 2016 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 logging
17
18 from ryu.ofproto import ether
19 from ryu.ofproto import ofproto_v1_4
20 from ryu.ofproto import ofproto_v1_4_parser
21 from ryu.lib import ofctl_utils
22
23 LOG = logging.getLogger(__name__)
24
25 DEFAULT_TIMEOUT = 1.0
26
27 UTIL = ofctl_utils.OFCtlUtil(ofproto_v1_4)
28 str_to_int = ofctl_utils.str_to_int
29
30
31 def to_action(dp, dic):
32     ofp = dp.ofproto
33     parser = dp.ofproto_parser
34     action_type = dic.get('type')
35     return ofctl_utils.to_action(dic, ofp, parser, action_type, UTIL)
36
37
38 def _get_actions(dp, dics):
39     actions = []
40     for d in dics:
41         action = to_action(dp, d)
42         if action is not None:
43             actions.append(action)
44         else:
45             LOG.error('Unknown action type: %s', d)
46     return actions
47
48
49 def to_instructions(dp, insts):
50     instructions = []
51     ofp = dp.ofproto
52     parser = dp.ofproto_parser
53
54     for i in insts:
55         inst_type = i.get('type')
56         if inst_type in ['APPLY_ACTIONS', 'WRITE_ACTIONS']:
57             dics = i.get('actions', [])
58             actions = _get_actions(dp, dics)
59             if actions:
60                 if inst_type == 'APPLY_ACTIONS':
61                     instructions.append(
62                         parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS,
63                                                      actions))
64                 else:
65                     instructions.append(
66                         parser.OFPInstructionActions(ofp.OFPIT_WRITE_ACTIONS,
67                                                      actions))
68         elif inst_type == 'CLEAR_ACTIONS':
69             instructions.append(
70                 parser.OFPInstructionActions(ofp.OFPIT_CLEAR_ACTIONS, []))
71         elif inst_type == 'GOTO_TABLE':
72             table_id = str_to_int(i.get('table_id'))
73             instructions.append(parser.OFPInstructionGotoTable(table_id))
74         elif inst_type == 'WRITE_METADATA':
75             metadata = str_to_int(i.get('metadata'))
76             metadata_mask = (str_to_int(i['metadata_mask'])
77                              if 'metadata_mask' in i
78                              else parser.UINT64_MAX)
79             instructions.append(
80                 parser.OFPInstructionWriteMetadata(
81                     metadata, metadata_mask))
82         elif inst_type == 'METER':
83             meter_id = str_to_int(i.get('meter_id'))
84             instructions.append(parser.OFPInstructionMeter(meter_id))
85         else:
86             LOG.error('Unknown instruction type: %s', inst_type)
87
88     return instructions
89
90
91 def action_to_str(act):
92     s = act.to_jsondict()[act.__class__.__name__]
93     t = UTIL.ofp_action_type_to_user(s['type'])
94     s['type'] = t if t != s['type'] else 'UNKNOWN'
95
96     if 'field' in s:
97         field = s.pop('field')
98         s['field'] = field['OXMTlv']['field']
99         s['mask'] = field['OXMTlv']['mask']
100         s['value'] = field['OXMTlv']['value']
101
102     return s
103
104
105 def instructions_to_str(instructions):
106
107     s = []
108
109     for i in instructions:
110         v = i.to_jsondict()[i.__class__.__name__]
111         t = UTIL.ofp_instruction_type_to_user(v['type'])
112         inst_type = t if t != v['type'] else 'UNKNOWN'
113         # apply/write/clear-action instruction
114         if isinstance(i, ofproto_v1_4_parser.OFPInstructionActions):
115             acts = []
116             for a in i.actions:
117                 acts.append(action_to_str(a))
118             v['type'] = inst_type
119             v['actions'] = acts
120             s.append(v)
121         # others
122         else:
123             v['type'] = inst_type
124             s.append(v)
125
126     return s
127
128
129 def to_match(dp, attrs):
130     convert = {'in_port': UTIL.ofp_port_from_user,
131                'in_phy_port': str_to_int,
132                'metadata': ofctl_utils.to_match_masked_int,
133                'eth_dst': ofctl_utils.to_match_eth,
134                'eth_src': ofctl_utils.to_match_eth,
135                'eth_type': str_to_int,
136                'vlan_vid': to_match_vid,
137                'vlan_pcp': str_to_int,
138                'ip_dscp': str_to_int,
139                'ip_ecn': str_to_int,
140                'ip_proto': str_to_int,
141                'ipv4_src': ofctl_utils.to_match_ip,
142                'ipv4_dst': ofctl_utils.to_match_ip,
143                'tcp_src': str_to_int,
144                'tcp_dst': str_to_int,
145                'udp_src': str_to_int,
146                'udp_dst': str_to_int,
147                'sctp_src': str_to_int,
148                'sctp_dst': str_to_int,
149                'icmpv4_type': str_to_int,
150                'icmpv4_code': str_to_int,
151                'arp_op': str_to_int,
152                'arp_spa': ofctl_utils.to_match_ip,
153                'arp_tpa': ofctl_utils.to_match_ip,
154                'arp_sha': ofctl_utils.to_match_eth,
155                'arp_tha': ofctl_utils.to_match_eth,
156                'ipv6_src': ofctl_utils.to_match_ip,
157                'ipv6_dst': ofctl_utils.to_match_ip,
158                'ipv6_flabel': str_to_int,
159                'icmpv6_type': str_to_int,
160                'icmpv6_code': str_to_int,
161                'ipv6_nd_target': ofctl_utils.to_match_ip,
162                'ipv6_nd_sll': ofctl_utils.to_match_eth,
163                'ipv6_nd_tll': ofctl_utils.to_match_eth,
164                'mpls_label': str_to_int,
165                'mpls_tc': str_to_int,
166                'mpls_bos': str_to_int,
167                'pbb_isid': ofctl_utils.to_match_masked_int,
168                'tunnel_id': ofctl_utils.to_match_masked_int,
169                'ipv6_exthdr': ofctl_utils.to_match_masked_int,
170                'pbb_uca': str_to_int}
171
172     keys = {'dl_dst': 'eth_dst',
173             'dl_src': 'eth_src',
174             'dl_type': 'eth_type',
175             'dl_vlan': 'vlan_vid',
176             'nw_src': 'ipv4_src',
177             'nw_dst': 'ipv4_dst',
178             'nw_proto': 'ip_proto'}
179
180     if attrs.get('eth_type') == ether.ETH_TYPE_ARP:
181         if 'ipv4_src' in attrs and 'arp_spa' not in attrs:
182             attrs['arp_spa'] = attrs['ipv4_src']
183             del attrs['ipv4_src']
184         if 'ipv4_dst' in attrs and 'arp_tpa' not in attrs:
185             attrs['arp_tpa'] = attrs['ipv4_dst']
186             del attrs['ipv4_dst']
187
188     kwargs = {}
189     for key, value in attrs.items():
190         if key in keys:
191             # For old field name
192             key = keys[key]
193         if key in convert:
194             value = convert[key](value)
195             kwargs[key] = value
196         else:
197             LOG.error('Unknown match field: %s', key)
198
199     return dp.ofproto_parser.OFPMatch(**kwargs)
200
201
202 def to_match_vid(value):
203     return ofctl_utils.to_match_vid(value, ofproto_v1_4.OFPVID_PRESENT)
204
205
206 def match_to_str(ofmatch):
207     match = {}
208
209     ofmatch = ofmatch.to_jsondict()['OFPMatch']
210     ofmatch = ofmatch['oxm_fields']
211
212     for match_field in ofmatch:
213         key = match_field['OXMTlv']['field']
214         mask = match_field['OXMTlv']['mask']
215         value = match_field['OXMTlv']['value']
216         if key == 'vlan_vid':
217             value = match_vid_to_str(value, mask)
218         elif key == 'in_port':
219             value = UTIL.ofp_port_to_user(value)
220         else:
221             if mask is not None:
222                 value = str(value) + '/' + str(mask)
223         match.setdefault(key, value)
224
225     return match
226
227
228 def match_vid_to_str(value, mask):
229     return ofctl_utils.match_vid_to_str(
230         value, mask, ofproto_v1_4.OFPVID_PRESENT)
231
232
233 def wrap_dpid_dict(dp, value, to_user=True):
234     if to_user:
235         return {str(dp.id): value}
236
237     return {dp.id: value}
238
239
240 def get_desc_stats(dp, waiters, to_user=True):
241     stats = dp.ofproto_parser.OFPDescStatsRequest(dp, 0)
242     msgs = []
243     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
244     s = {}
245
246     for msg in msgs:
247         stats = msg.body
248         s = stats.to_jsondict()[stats.__class__.__name__]
249
250     return wrap_dpid_dict(dp, s, to_user)
251
252
253 def get_queue_stats(dp, waiters, port_no=None, queue_id=None, to_user=True):
254     if port_no is None:
255         port_no = dp.ofproto.OFPP_ANY
256     else:
257         port_no = UTIL.ofp_port_from_user(port_no)
258     if queue_id is None:
259         queue_id = dp.ofproto.OFPQ_ALL
260     else:
261         queue_id = UTIL.ofp_queue_from_user(queue_id)
262
263     stats = dp.ofproto_parser.OFPQueueStatsRequest(
264         dp, 0, port_no, queue_id)
265     msgs = []
266     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
267
268     desc = []
269     for msg in msgs:
270         stats = msg.body
271         for stat in stats:
272             s = stat.to_jsondict()[stat.__class__.__name__]
273             properties = []
274             for prop in stat.properties:
275                 p = prop.to_jsondict()[prop.__class__.__name__]
276                 if to_user:
277                     t = UTIL.ofp_queue_stats_prop_type_to_user(prop.type)
278                     p['type'] = t if t != p['type'] else 'UNKNOWN'
279                 properties.append(p)
280             s['properties'] = properties
281             desc.append(s)
282
283     return wrap_dpid_dict(dp, desc, to_user)
284
285
286 def get_queue_desc(dp, waiters, port_no=None, queue_id=None, to_user=True):
287     if port_no is None:
288         port_no = dp.ofproto.OFPP_ANY
289     else:
290         port_no = UTIL.ofp_port_from_user(port_no)
291     if queue_id is None:
292         queue_id = dp.ofproto.OFPQ_ALL
293     else:
294         queue_id = UTIL.ofp_queue_from_user(queue_id)
295
296     stats = dp.ofproto_parser.OFPQueueDescStatsRequest(
297         dp, 0, port_no, queue_id)
298     msgs = []
299     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
300
301     configs = []
302     for msg in msgs:
303         for queue in msg.body:
304             q = queue.to_jsondict()[queue.__class__.__name__]
305             prop_list = []
306             for prop in queue.properties:
307                 p = prop.to_jsondict()[prop.__class__.__name__]
308                 if to_user:
309                     t = UTIL.ofp_queue_desc_prop_type_to_user(prop.type)
310                     p['type'] = t if t != prop.type else 'UNKNOWN'
311                 prop_list.append(p)
312             q['properties'] = prop_list
313             configs.append(q)
314
315     return wrap_dpid_dict(dp, configs, to_user)
316
317
318 def get_flow_stats(dp, waiters, flow=None, to_user=True):
319     flow = flow if flow else {}
320     table_id = UTIL.ofp_table_from_user(
321         flow.get('table_id', dp.ofproto.OFPTT_ALL))
322     flags = str_to_int(flow.get('flags', 0))
323     out_port = UTIL.ofp_port_from_user(
324         flow.get('out_port', dp.ofproto.OFPP_ANY))
325     out_group = UTIL.ofp_group_from_user(
326         flow.get('out_group', dp.ofproto.OFPG_ANY))
327     cookie = str_to_int(flow.get('cookie', 0))
328     cookie_mask = str_to_int(flow.get('cookie_mask', 0))
329     match = to_match(dp, flow.get('match', {}))
330     # Note: OpenFlow does not allow to filter flow entries by priority,
331     # but for efficiency, ofctl provides the way to do it.
332     priority = str_to_int(flow.get('priority', -1))
333
334     stats = dp.ofproto_parser.OFPFlowStatsRequest(
335         dp, flags, table_id, out_port, out_group, cookie, cookie_mask,
336         match)
337
338     msgs = []
339     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
340
341     flows = []
342     for msg in msgs:
343         for stats in msg.body:
344             if 0 <= priority != stats.priority:
345                 continue
346
347             s = stats.to_jsondict()[stats.__class__.__name__]
348             s['instructions'] = instructions_to_str(stats.instructions)
349             s['match'] = match_to_str(stats.match)
350             flows.append(s)
351
352     return wrap_dpid_dict(dp, flows, to_user)
353
354
355 def get_aggregate_flow_stats(dp, waiters, flow=None, to_user=True):
356     flow = flow if flow else {}
357     table_id = UTIL.ofp_table_from_user(
358         flow.get('table_id', dp.ofproto.OFPTT_ALL))
359     flags = str_to_int(flow.get('flags', 0))
360     out_port = UTIL.ofp_port_from_user(
361         flow.get('out_port', dp.ofproto.OFPP_ANY))
362     out_group = UTIL.ofp_group_from_user(
363         flow.get('out_group', dp.ofproto.OFPG_ANY))
364     cookie = str_to_int(flow.get('cookie', 0))
365     cookie_mask = str_to_int(flow.get('cookie_mask', 0))
366     match = to_match(dp, flow.get('match', {}))
367
368     stats = dp.ofproto_parser.OFPAggregateStatsRequest(
369         dp, flags, table_id, out_port, out_group, cookie, cookie_mask,
370         match)
371
372     msgs = []
373     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
374
375     flows = []
376     for msg in msgs:
377         stats = msg.body
378         s = stats.to_jsondict()[stats.__class__.__name__]
379         flows.append(s)
380
381     return wrap_dpid_dict(dp, flows, to_user)
382
383
384 def get_table_stats(dp, waiters, to_user=True):
385     stats = dp.ofproto_parser.OFPTableStatsRequest(dp, 0)
386     msgs = []
387     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
388
389     tables = []
390     for msg in msgs:
391         stats = msg.body
392         for stat in stats:
393             s = stat.to_jsondict()[stat.__class__.__name__]
394
395             if to_user:
396                 s['table_id'] = UTIL.ofp_table_to_user(stat.table_id)
397
398             tables.append(s)
399
400     return wrap_dpid_dict(dp, tables, to_user)
401
402
403 def get_table_features(dp, waiters, to_user=True):
404     stats = dp.ofproto_parser.OFPTableFeaturesStatsRequest(dp, 0, [])
405     msgs = []
406     ofproto = dp.ofproto
407     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
408
409     p_type_instructions = [ofproto.OFPTFPT_INSTRUCTIONS,
410                            ofproto.OFPTFPT_INSTRUCTIONS_MISS]
411
412     p_type_next_tables = [ofproto.OFPTFPT_NEXT_TABLES,
413                           ofproto.OFPTFPT_NEXT_TABLES_MISS,
414                           ofproto.OFPTFPT_TABLE_SYNC_FROM]
415
416     p_type_actions = [ofproto.OFPTFPT_WRITE_ACTIONS,
417                       ofproto.OFPTFPT_WRITE_ACTIONS_MISS,
418                       ofproto.OFPTFPT_APPLY_ACTIONS,
419                       ofproto.OFPTFPT_APPLY_ACTIONS_MISS]
420
421     p_type_oxms = [ofproto.OFPTFPT_MATCH,
422                    ofproto.OFPTFPT_WILDCARDS,
423                    ofproto.OFPTFPT_WRITE_SETFIELD,
424                    ofproto.OFPTFPT_WRITE_SETFIELD_MISS,
425                    ofproto.OFPTFPT_APPLY_SETFIELD,
426                    ofproto.OFPTFPT_APPLY_SETFIELD_MISS]
427
428     p_type_experimenter = [ofproto.OFPTFPT_EXPERIMENTER,
429                            ofproto.OFPTFPT_EXPERIMENTER_MISS]
430
431     tables = []
432     for msg in msgs:
433         stats = msg.body
434         for stat in stats:
435             s = stat.to_jsondict()[stat.__class__.__name__]
436             properties = []
437             for prop in stat.properties:
438                 p = {}
439                 t = UTIL.ofp_table_feature_prop_type_to_user(prop.type)
440                 p['type'] = t if t != prop.type else 'UNKNOWN'
441                 if prop.type in p_type_instructions:
442                     instruction_ids = []
443                     for i in prop.instruction_ids:
444                         inst = {'len': i.len,
445                                 'type': i.type}
446                         instruction_ids.append(inst)
447                     p['instruction_ids'] = instruction_ids
448                 elif prop.type in p_type_next_tables:
449                     table_ids = []
450                     for i in prop.table_ids:
451                         table_ids.append(i)
452                     p['table_ids'] = table_ids
453                 elif prop.type in p_type_actions:
454                     action_ids = []
455                     for i in prop.action_ids:
456                         act = i.to_jsondict()[i.__class__.__name__]
457                         action_ids.append(act)
458                     p['action_ids'] = action_ids
459                 elif prop.type in p_type_oxms:
460                     oxm_ids = []
461                     for i in prop.oxm_ids:
462                         oxm = i.to_jsondict()[i.__class__.__name__]
463                         oxm_ids.append(oxm)
464                     p['oxm_ids'] = oxm_ids
465                 elif prop.type in p_type_experimenter:
466                     pass
467                 properties.append(p)
468             s['name'] = stat.name.decode('utf-8')
469             s['properties'] = properties
470
471             if to_user:
472                 s['table_id'] = UTIL.ofp_table_to_user(stat.table_id)
473
474             tables.append(s)
475
476     return wrap_dpid_dict(dp, tables, to_user)
477
478
479 def get_port_stats(dp, waiters, port_no=None, to_user=True):
480     if port_no is None:
481         port_no = dp.ofproto.OFPP_ANY
482     else:
483         port_no = UTIL.ofp_port_from_user(port_no)
484
485     stats = dp.ofproto_parser.OFPPortStatsRequest(dp, 0, port_no)
486     msgs = []
487     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
488
489     ports = []
490     for msg in msgs:
491         for stats in msg.body:
492             s = stats.to_jsondict()[stats.__class__.__name__]
493             properties = []
494             for prop in stats.properties:
495                 p = prop.to_jsondict()[prop.__class__.__name__]
496                 t = UTIL.ofp_port_stats_prop_type_to_user(prop.type)
497                 p['type'] = t if t != prop.type else 'UNKNOWN'
498                 properties.append(p)
499             s['properties'] = properties
500
501             if to_user:
502                 s['port_no'] = UTIL.ofp_port_to_user(stats.port_no)
503
504             ports.append(s)
505
506     return wrap_dpid_dict(dp, ports, to_user)
507
508
509 def get_meter_stats(dp, waiters, meter_id=None, to_user=True):
510     if meter_id is None:
511         meter_id = dp.ofproto.OFPM_ALL
512     else:
513         meter_id = UTIL.ofp_meter_from_user(meter_id)
514
515     stats = dp.ofproto_parser.OFPMeterStatsRequest(
516         dp, 0, meter_id)
517     msgs = []
518     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
519
520     meters = []
521     for msg in msgs:
522         for stats in msg.body:
523             s = stats.to_jsondict()[stats.__class__.__name__]
524             bands = []
525             for band in stats.band_stats:
526                 b = band.to_jsondict()[band.__class__.__name__]
527                 bands.append(b)
528             s['band_stats'] = bands
529
530             if to_user:
531                 s['meter_id'] = UTIL.ofp_meter_to_user(stats.meter_id)
532
533             meters.append(s)
534
535     return wrap_dpid_dict(dp, meters, to_user)
536
537
538 def get_meter_features(dp, waiters, to_user=True):
539     ofp = dp.ofproto
540     type_convert = {ofp.OFPMBT_DROP: 'DROP',
541                     ofp.OFPMBT_DSCP_REMARK: 'DSCP_REMARK'}
542
543     capa_convert = {ofp.OFPMF_KBPS: 'KBPS',
544                     ofp.OFPMF_PKTPS: 'PKTPS',
545                     ofp.OFPMF_BURST: 'BURST',
546                     ofp.OFPMF_STATS: 'STATS'}
547
548     stats = dp.ofproto_parser.OFPMeterFeaturesStatsRequest(dp, 0)
549     msgs = []
550     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
551
552     features = []
553     for msg in msgs:
554         for feature in msg.body:
555             band_types = []
556             for k, v in type_convert.items():
557                 if (1 << k) & feature.band_types:
558
559                     if to_user:
560                         band_types.append(v)
561
562                     else:
563                         band_types.append(k)
564
565             capabilities = []
566             for k, v in sorted(capa_convert.items()):
567                 if k & feature.capabilities:
568
569                     if to_user:
570                         capabilities.append(v)
571
572                     else:
573                         capabilities.append(k)
574
575             f = {'max_meter': feature.max_meter,
576                  'band_types': band_types,
577                  'capabilities': capabilities,
578                  'max_bands': feature.max_bands,
579                  'max_color': feature.max_color}
580             features.append(f)
581
582     return wrap_dpid_dict(dp, features, to_user)
583
584
585 def get_meter_config(dp, waiters, meter_id=None, to_user=True):
586     flags = {dp.ofproto.OFPMF_KBPS: 'KBPS',
587              dp.ofproto.OFPMF_PKTPS: 'PKTPS',
588              dp.ofproto.OFPMF_BURST: 'BURST',
589              dp.ofproto.OFPMF_STATS: 'STATS'}
590
591     if meter_id is None:
592         meter_id = dp.ofproto.OFPM_ALL
593     else:
594         meter_id = UTIL.ofp_meter_from_user(meter_id)
595
596     stats = dp.ofproto_parser.OFPMeterConfigStatsRequest(
597         dp, 0, meter_id)
598     msgs = []
599     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
600
601     configs = []
602     for msg in msgs:
603         for config in msg.body:
604             c = config.to_jsondict()[config.__class__.__name__]
605             bands = []
606             for band in config.bands:
607                 b = band.to_jsondict()[band.__class__.__name__]
608
609                 if to_user:
610                     t = UTIL.ofp_meter_band_type_to_user(band.type)
611                     b['type'] = t if t != band.type else 'UNKNOWN'
612
613                 bands.append(b)
614             c_flags = []
615             for k, v in sorted(flags.items()):
616                 if k & config.flags:
617                     if to_user:
618                         c_flags.append(v)
619
620                     else:
621                         c_flags.append(k)
622
623             c['flags'] = c_flags
624             c['bands'] = bands
625
626             if to_user:
627                 c['meter_id'] = UTIL.ofp_meter_to_user(config.meter_id)
628
629             configs.append(c)
630
631     return wrap_dpid_dict(dp, configs, to_user)
632
633
634 def get_group_stats(dp, waiters, group_id=None, to_user=True):
635     if group_id is None:
636         group_id = dp.ofproto.OFPG_ALL
637     else:
638         group_id = UTIL.ofp_group_from_user(group_id)
639
640     stats = dp.ofproto_parser.OFPGroupStatsRequest(
641         dp, 0, group_id)
642     msgs = []
643     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
644
645     groups = []
646     for msg in msgs:
647         for stats in msg.body:
648             g = stats.to_jsondict()[stats.__class__.__name__]
649             bucket_stats = []
650             for bucket_stat in stats.bucket_stats:
651                 c = bucket_stat.to_jsondict()[bucket_stat.__class__.__name__]
652                 bucket_stats.append(c)
653             g['bucket_stats'] = bucket_stats
654
655             if to_user:
656                 g['group_id'] = UTIL.ofp_group_to_user(stats.group_id)
657
658             groups.append(g)
659
660     return wrap_dpid_dict(dp, groups, to_user)
661
662
663 def get_group_features(dp, waiters, to_user=True):
664
665     ofp = dp.ofproto
666     type_convert = {ofp.OFPGT_ALL: 'ALL',
667                     ofp.OFPGT_SELECT: 'SELECT',
668                     ofp.OFPGT_INDIRECT: 'INDIRECT',
669                     ofp.OFPGT_FF: 'FF'}
670     cap_convert = {ofp.OFPGFC_SELECT_WEIGHT: 'SELECT_WEIGHT',
671                    ofp.OFPGFC_SELECT_LIVENESS: 'SELECT_LIVENESS',
672                    ofp.OFPGFC_CHAINING: 'CHAINING',
673                    ofp.OFPGFC_CHAINING_CHECKS: 'CHAINING_CHECKS'}
674     act_convert = {ofp.OFPAT_OUTPUT: 'OUTPUT',
675                    ofp.OFPAT_COPY_TTL_OUT: 'COPY_TTL_OUT',
676                    ofp.OFPAT_COPY_TTL_IN: 'COPY_TTL_IN',
677                    ofp.OFPAT_SET_MPLS_TTL: 'SET_MPLS_TTL',
678                    ofp.OFPAT_DEC_MPLS_TTL: 'DEC_MPLS_TTL',
679                    ofp.OFPAT_PUSH_VLAN: 'PUSH_VLAN',
680                    ofp.OFPAT_POP_VLAN: 'POP_VLAN',
681                    ofp.OFPAT_PUSH_MPLS: 'PUSH_MPLS',
682                    ofp.OFPAT_POP_MPLS: 'POP_MPLS',
683                    ofp.OFPAT_SET_QUEUE: 'SET_QUEUE',
684                    ofp.OFPAT_GROUP: 'GROUP',
685                    ofp.OFPAT_SET_NW_TTL: 'SET_NW_TTL',
686                    ofp.OFPAT_DEC_NW_TTL: 'DEC_NW_TTL',
687                    ofp.OFPAT_SET_FIELD: 'SET_FIELD',
688                    ofp.OFPAT_PUSH_PBB: 'PUSH_PBB',
689                    ofp.OFPAT_POP_PBB: 'POP_PBB',
690                    ofp.OFPAT_EXPERIMENTER: 'EXPERIMENTER'}
691
692     stats = dp.ofproto_parser.OFPGroupFeaturesStatsRequest(dp, 0)
693     msgs = []
694     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
695
696     features = []
697     for msg in msgs:
698         feature = msg.body
699         types = []
700         for k, v in type_convert.items():
701             if (1 << k) & feature.types:
702                 if to_user:
703                     types.append(v)
704
705                 else:
706                     types.append(k)
707
708         capabilities = []
709         for k, v in cap_convert.items():
710             if k & feature.capabilities:
711                 if to_user:
712                     capabilities.append(v)
713
714                 else:
715                     capabilities.append(k)
716
717         if to_user:
718             max_groups = []
719             for k, v in type_convert.items():
720                 max_groups.append({v: feature.max_groups[k]})
721
722         else:
723             max_groups = feature.max_groups
724
725         actions = []
726         for k1, v1 in type_convert.items():
727             acts = []
728             for k2, v2 in act_convert.items():
729                 if (1 << k2) & feature.actions[k1]:
730                     if to_user:
731                         acts.append(v2)
732
733                     else:
734                         acts.append(k2)
735
736             if to_user:
737                 actions.append({v1: acts})
738
739             else:
740                 actions.append({k1: acts})
741
742         f = {'types': types,
743              'capabilities': capabilities,
744              'max_groups': max_groups,
745              'actions': actions}
746         features.append(f)
747
748     return wrap_dpid_dict(dp, features, to_user)
749
750
751 def get_group_desc(dp, waiters, to_user=True):
752     stats = dp.ofproto_parser.OFPGroupDescStatsRequest(dp, 0)
753     msgs = []
754     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
755
756     descs = []
757     for msg in msgs:
758         for stats in msg.body:
759             d = stats.to_jsondict()[stats.__class__.__name__]
760             buckets = []
761             for bucket in stats.buckets:
762                 b = bucket.to_jsondict()[bucket.__class__.__name__]
763                 actions = []
764                 for action in bucket.actions:
765                     if to_user:
766                         actions.append(action_to_str(action))
767
768                     else:
769                         actions.append(action)
770                 b['actions'] = actions
771                 buckets.append(b)
772
773             d['buckets'] = buckets
774             if to_user:
775                 d['group_id'] = UTIL.ofp_group_to_user(stats.group_id)
776                 t = UTIL.ofp_group_type_to_user(stats.type)
777                 d['type'] = t if t != stats.type else 'UNKNOWN'
778
779             descs.append(d)
780
781     return wrap_dpid_dict(dp, descs, to_user)
782
783
784 def get_port_desc(dp, waiters, port_no=None, to_user=True):
785     if port_no is None:
786         port_no = dp.ofproto.OFPP_ANY
787     else:
788         port_no = UTIL.ofp_port_from_user(port_no)
789
790     stats = dp.ofproto_parser.OFPPortDescStatsRequest(dp, 0, port_no)
791     msgs = []
792     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
793
794     descs = []
795
796     for msg in msgs:
797         stats = msg.body
798         for stat in stats:
799             d = stat.to_jsondict()[stat.__class__.__name__]
800             properties = []
801             for prop in stat.properties:
802                 p = prop.to_jsondict()[prop.__class__.__name__]
803
804                 if to_user:
805                     t = UTIL.ofp_port_desc_prop_type_to_user(prop.type)
806                     p['type'] = t if t != prop.type else 'UNKNOWN'
807
808                 properties.append(p)
809             d['name'] = stat.name.decode('utf-8')
810             d['properties'] = properties
811
812             if to_user:
813                 d['port_no'] = UTIL.ofp_port_to_user(stat.port_no)
814
815             descs.append(d)
816
817     return wrap_dpid_dict(dp, descs, to_user)
818
819
820 def get_role(dp, waiters, to_user=True):
821     return ofctl_utils.get_role(dp, waiters, to_user)
822
823
824 def mod_flow_entry(dp, flow, cmd):
825     cookie = str_to_int(flow.get('cookie', 0))
826     cookie_mask = str_to_int(flow.get('cookie_mask', 0))
827     table_id = UTIL.ofp_table_from_user(flow.get('table_id', 0))
828     idle_timeout = str_to_int(flow.get('idle_timeout', 0))
829     hard_timeout = str_to_int(flow.get('hard_timeout', 0))
830     priority = str_to_int(flow.get('priority', 0))
831     buffer_id = UTIL.ofp_buffer_from_user(
832         flow.get('buffer_id', dp.ofproto.OFP_NO_BUFFER))
833     out_port = UTIL.ofp_port_from_user(
834         flow.get('out_port', dp.ofproto.OFPP_ANY))
835     out_group = UTIL.ofp_group_from_user(
836         flow.get('out_group', dp.ofproto.OFPG_ANY))
837     importance = str_to_int(flow.get('importance', 0))
838     flags = str_to_int(flow.get('flags', 0))
839     match = to_match(dp, flow.get('match', {}))
840     inst = to_instructions(dp, flow.get('instructions', []))
841
842     flow_mod = dp.ofproto_parser.OFPFlowMod(
843         dp, cookie, cookie_mask, table_id, cmd, idle_timeout,
844         hard_timeout, priority, buffer_id, out_port, out_group,
845         flags, importance, match, inst)
846
847     ofctl_utils.send_msg(dp, flow_mod, LOG)
848
849
850 def mod_meter_entry(dp, meter, cmd):
851     flags = 0
852     if 'flags' in meter:
853         meter_flags = meter['flags']
854         if not isinstance(meter_flags, list):
855             meter_flags = [meter_flags]
856         for flag in meter_flags:
857             t = UTIL.ofp_meter_flags_from_user(flag)
858             f = t if t != flag else None
859             if f is None:
860                 LOG.error('Unknown meter flag: %s', flag)
861                 continue
862             flags |= f
863
864     meter_id = UTIL.ofp_meter_from_user(meter.get('meter_id', 0))
865
866     bands = []
867     for band in meter.get('bands', []):
868         band_type = band.get('type')
869         rate = str_to_int(band.get('rate', 0))
870         burst_size = str_to_int(band.get('burst_size', 0))
871         if band_type == 'DROP':
872             bands.append(
873                 dp.ofproto_parser.OFPMeterBandDrop(rate, burst_size))
874         elif band_type == 'DSCP_REMARK':
875             prec_level = str_to_int(band.get('prec_level', 0))
876             bands.append(
877                 dp.ofproto_parser.OFPMeterBandDscpRemark(
878                     rate, burst_size, prec_level))
879         elif band_type == 'EXPERIMENTER':
880             experimenter = str_to_int(band.get('experimenter', 0))
881             bands.append(
882                 dp.ofproto_parser.OFPMeterBandExperimenter(
883                     rate, burst_size, experimenter))
884         else:
885             LOG.error('Unknown band type: %s', band_type)
886
887     meter_mod = dp.ofproto_parser.OFPMeterMod(
888         dp, cmd, flags, meter_id, bands)
889
890     ofctl_utils.send_msg(dp, meter_mod, LOG)
891
892
893 def mod_group_entry(dp, group, cmd):
894     group_type = str(group.get('type', 'ALL'))
895     t = UTIL.ofp_group_type_from_user(group_type)
896     group_type = t if t != group_type else None
897     if group_type is None:
898         LOG.error('Unknown group type: %s', group.get('type'))
899
900     group_id = UTIL.ofp_group_from_user(group.get('group_id', 0))
901
902     buckets = []
903     for bucket in group.get('buckets', []):
904         weight = str_to_int(bucket.get('weight', 0))
905         watch_port = str_to_int(
906             bucket.get('watch_port', dp.ofproto.OFPP_ANY))
907         watch_group = str_to_int(
908             bucket.get('watch_group', dp.ofproto.OFPG_ANY))
909         actions = []
910         for dic in bucket.get('actions', []):
911             action = to_action(dp, dic)
912             if action is not None:
913                 actions.append(action)
914         buckets.append(dp.ofproto_parser.OFPBucket(
915             weight, watch_port, watch_group, actions))
916
917     group_mod = dp.ofproto_parser.OFPGroupMod(
918         dp, cmd, group_type, group_id, buckets)
919
920     ofctl_utils.send_msg(dp, group_mod, LOG)
921
922
923 def mod_port_behavior(dp, port_config):
924     ofp = dp.ofproto
925     parser = dp.ofproto_parser
926     port_no = UTIL.ofp_port_from_user(port_config.get('port_no', 0))
927     hw_addr = str(port_config.get('hw_addr'))
928     config = str_to_int(port_config.get('config', 0))
929     mask = str_to_int(port_config.get('mask', 0))
930     properties = port_config.get('properties')
931
932     prop = []
933     for p in properties:
934         type_ = UTIL.ofp_port_mod_prop_type_from_user(p['type'])
935         length = None
936         if type_ == ofp.OFPPDPT_ETHERNET:
937             advertise = UTIL.ofp_port_features_from_user(p['advertise'])
938             prop.append(
939                 parser.OFPPortModPropEthernet(type_, length, advertise))
940         elif type_ == ofp.OFPPDPT_OPTICAL:
941             prop.append(
942                 parser.OFPPortModPropOptical(
943                     type_, length, p['configure'], p['freq_lmda'],
944                     p['fl_offset'], p['grid_span'], p['tx_pwr']))
945         elif type_ == ofp.OFPPDPT_EXPERIMENTER:
946             prop.append(
947                 parser.OFPPortModPropExperimenter(
948                     type_, length, p['experimenter'], p['exp_type'],
949                     p['data']))
950         else:
951             LOG.error('Unknown port desc prop type: %s', type_)
952
953     port_mod = dp.ofproto_parser.OFPPortMod(
954         dp, port_no, hw_addr, config, mask, prop)
955
956     ofctl_utils.send_msg(dp, port_mod, LOG)
957
958
959 def set_role(dp, role):
960     r = UTIL.ofp_role_from_user(role.get('role', dp.ofproto.OFPCR_ROLE_EQUAL))
961     role_request = dp.ofproto_parser.OFPRoleRequest(dp, r, 0)
962     ofctl_utils.send_msg(dp, role_request, LOG)
963
964
965 # NOTE(jkoelker) Alias common funcitons
966 send_experimenter = ofctl_utils.send_experimenter