diff --git a/ryu/lib/ofctl_utils.py b/ryu/lib/ofctl_utils.py index 978d1f6e..3ec8c36a 100644 --- a/ryu/lib/ofctl_utils.py +++ b/ryu/lib/ofctl_utils.py @@ -27,6 +27,8 @@ class OFCtlUtil(object): def __init__(self, ofproto): self.ofproto = ofproto + self.deprecated_value = [ + 'OFPTFPT_EXPERIMENTER_SLAVE', 'OFPTFPT_EXPERIMENTER_MASTER'] def _reserved_num_from_user(self, num, prefix): if isinstance(num, int): @@ -39,10 +41,83 @@ class OFCtlUtil(object): def _reserved_num_to_user(self, num, prefix): for k, v in self.ofproto.__dict__.items(): - if k.startswith(prefix) and v == num: - return k.replace(prefix, '') + if k not in self.deprecated_value and \ + k.startswith(prefix) and v == num: + return k.replace(prefix, '') return num + def ofp_port_features_from_user(self, act): + return self._reserved_num_from_user(act, 'OFPPF_') + + def ofp_port_features_to_user(self, act): + return self._reserved_num_to_user(act, 'OFPPF_') + + def ofp_port_mod_prop_type_from_user(self, act): + return self._reserved_num_from_user(act, 'OFPPMPT_') + + def ofp_port_mod_prop_type_to_user(self, act): + return self._reserved_num_to_user(act, 'OFPPMPT_') + + def ofp_port_desc_prop_type_from_user(self, act): + return self._reserved_num_from_user(act, 'OFPPDPT_') + + def ofp_port_desc_prop_type_to_user(self, act): + return self._reserved_num_to_user(act, 'OFPPDPT_') + + def ofp_action_type_from_user(self, act): + return self._reserved_num_from_user(act, 'OFPAT_') + + def ofp_action_type_to_user(self, act): + return self._reserved_num_to_user(act, 'OFPAT_') + + def ofp_instruction_type_from_user(self, act): + return self._reserved_num_from_user(act, 'OFPIT_') + + def ofp_instruction_type_to_user(self, act): + return self._reserved_num_to_user(act, 'OFPIT_') + + def ofp_group_type_from_user(self, act): + return self._reserved_num_from_user(act, 'OFPGT_') + + def ofp_group_type_to_user(self, act): + return self._reserved_num_to_user(act, 'OFPGT_') + + def ofp_meter_band_type_from_user(self, act): + return self._reserved_num_from_user(act, 'OFPMBT_') + + def ofp_meter_band_type_to_user(self, act): + return self._reserved_num_to_user(act, 'OFPMBT_') + + def ofp_table_feature_prop_type_from_user(self, act): + return self._reserved_num_from_user(act, 'OFPTFPT_') + + def ofp_table_feature_prop_type_to_user(self, act): + return self._reserved_num_to_user(act, 'OFPTFPT_') + + def ofp_port_stats_prop_type_from_user(self, act): + return self._reserved_num_from_user(act, 'OFPPSPT_') + + def ofp_port_stats_prop_type_to_user(self, act): + return self._reserved_num_to_user(act, 'OFPPSPT_') + + def ofp_queue_desc_prop_type_from_user(self, act): + return self._reserved_num_from_user(act, 'OFPQDPT_') + + def ofp_queue_desc_prop_type_to_user(self, act): + return self._reserved_num_to_user(act, 'OFPQDPT_') + + def ofp_queue_stats_prop_type_from_user(self, act): + return self._reserved_num_from_user(act, 'OFPQSPT_') + + def ofp_queue_stats_prop_type_to_user(self, act): + return self._reserved_num_to_user(act, 'OFPQSPT_') + + def ofp_meter_flags_from_user(self, act): + return self._reserved_num_from_user(act, 'OFPMF_') + + def ofp_meter_flags_to_user(self, act): + return self._reserved_num_to_user(act, 'OFPMF_') + def ofp_port_from_user(self, port): return self._reserved_num_from_user(port, 'OFPP_') @@ -67,6 +142,12 @@ class OFCtlUtil(object): def ofp_group_to_user(self, group): return self._reserved_num_to_user(group, 'OFPG_') + def ofp_group_capabilities_from_user(self, group): + return self._reserved_num_from_user(group, 'OFPGFC_') + + def ofp_group_capabilities_to_user(self, group): + return self._reserved_num_to_user(group, 'OFPGFC_') + def ofp_buffer_from_user(self, buffer): if buffer in ['OFP_NO_BUFFER', 'NO_BUFFER']: return self.ofproto.OFP_NO_BUFFER diff --git a/ryu/lib/ofctl_v1_4.py b/ryu/lib/ofctl_v1_4.py new file mode 100644 index 00000000..3e4405f3 --- /dev/null +++ b/ryu/lib/ofctl_v1_4.py @@ -0,0 +1,979 @@ +# Copyright (C) 2016 Nippon Telegraph and Telephone Corporation. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or +# implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import base64 +import logging +import netaddr +import six + +from ryu.ofproto import ether +from ryu.ofproto import inet +from ryu.ofproto import ofproto_v1_4 +from ryu.ofproto import ofproto_v1_4_parser +from ryu.lib import hub +from ryu.lib import ofctl_utils + +LOG = logging.getLogger(__name__) + +DEFAULT_TIMEOUT = 1.0 + +UTIL = ofctl_utils.OFCtlUtil(ofproto_v1_4) + + +def to_action(dp, dic): + ofp = dp.ofproto + parser = dp.ofproto_parser + + action_type = dic.get('type') + + if action_type == 'OUTPUT': + out_port = UTIL.ofp_port_from_user(dic.get('port', ofp.OFPP_ANY)) + max_len = UTIL.ofp_cml_from_user(dic.get('max_len', ofp.OFPCML_MAX)) + action = parser.OFPActionOutput(out_port, max_len) + elif action_type == 'COPY_TTL_OUT': + action = parser.OFPActionCopyTtlOut() + elif action_type == 'COPY_TTL_IN': + action = parser.OFPActionCopyTtlIn() + elif action_type == 'SET_MPLS_TTL': + mpls_ttl = int(dic.get('mpls_ttl')) + action = parser.OFPActionSetMplsTtl(mpls_ttl) + elif action_type == 'DEC_MPLS_TTL': + action = parser.OFPActionDecMplsTtl() + elif action_type == 'PUSH_VLAN': + ethertype = int(dic.get('ethertype')) + action = parser.OFPActionPushVlan(ethertype) + elif action_type == 'POP_VLAN': + action = parser.OFPActionPopVlan() + elif action_type == 'PUSH_MPLS': + ethertype = int(dic.get('ethertype')) + action = parser.OFPActionPushMpls(ethertype) + elif action_type == 'POP_MPLS': + ethertype = int(dic.get('ethertype')) + action = parser.OFPActionPopMpls(ethertype) + elif action_type == 'SET_QUEUE': + queue_id = UTIL.ofp_queue_from_user(dic.get('queue_id')) + action = parser.OFPActionSetQueue(queue_id) + elif action_type == 'GROUP': + group_id = UTIL.ofp_group_from_user(dic.get('group_id')) + action = parser.OFPActionGroup(group_id) + elif action_type == 'SET_NW_TTL': + nw_ttl = int(dic.get('nw_ttl')) + action = parser.OFPActionSetNwTtl(nw_ttl) + elif action_type == 'DEC_NW_TTL': + action = parser.OFPActionDecNwTtl() + elif action_type == 'SET_FIELD': + field = dic.get('field') + value = dic.get('value') + action = parser.OFPActionSetField(**{field: value}) + elif action_type == 'PUSH_PBB': + ethertype = int(dic.get('ethertype')) + action = parser.OFPActionPushPbb(ethertype) + elif action_type == 'POP_PBB': + action = parser.OFPActionPopPbb() + elif action_type == 'EXPERIMENTER': + experimenter = int(dic.get('experimenter')) + data_type = dic.get('data_type', 'ascii') + if data_type != 'ascii' and data_type != 'base64': + LOG.error('Unknown data type: %s', data_type) + data = dic.get('data', '') + if data_type == 'base64': + data = base64.b64decode(data) + action = parser.OFPActionExperimenterUnknown(experimenter, data) + else: + action = None + + return action + + +def _get_actions(dp, dics): + actions = [] + for d in dics: + action = to_action(dp, d) + if action is not None: + actions.append(action) + else: + LOG.error('Unknown action type: %s', d) + return actions + + +def to_instructions(dp, insts): + instructions = [] + ofp = dp.ofproto + parser = dp.ofproto_parser + + for i in insts: + inst_type = i.get('type') + if inst_type in ['APPLY_ACTIONS', 'WRITE_ACTIONS']: + dics = i.get('actions', []) + actions = _get_actions(dp, dics) + if actions: + if inst_type == 'APPLY_ACTIONS': + instructions.append( + parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, + actions)) + else: + instructions.append( + parser.OFPInstructionActions(ofp.OFPIT_WRITE_ACTIONS, + actions)) + elif inst_type == 'CLEAR_ACTIONS': + instructions.append( + parser.OFPInstructionActions(ofp.OFPIT_CLEAR_ACTIONS, [])) + elif inst_type == 'GOTO_TABLE': + table_id = int(i.get('table_id')) + instructions.append(parser.OFPInstructionGotoTable(table_id)) + elif inst_type == 'WRITE_METADATA': + metadata = ofctl_utils.str_to_int(i.get('metadata')) + metadata_mask = (ofctl_utils.str_to_int(i['metadata_mask']) + if 'metadata_mask' in i + else parser.UINT64_MAX) + instructions.append( + parser.OFPInstructionWriteMetadata( + metadata, metadata_mask)) + elif inst_type == 'METER': + meter_id = int(i.get('meter_id')) + instructions.append(parser.OFPInstructionMeter(meter_id)) + else: + LOG.error('Unknown instruction type: %s', inst_type) + + return instructions + + +def action_to_str(act): + s = act.to_jsondict()[act.__class__.__name__] + t = UTIL.ofp_action_type_to_user(s['type']) + s['type'] = t if t != s['type'] else 'UNKNOWN' + + if 'field' in s: + field = s.pop('field') + s['field'] = field['OXMTlv']['field'] + s['mask'] = field['OXMTlv']['mask'] + s['value'] = field['OXMTlv']['value'] + + return s + + +def _remove(d, names): + f = lambda x: _remove(x, names) + if isinstance(d, list): + return list(map(f, d)) + if isinstance(d, dict): + d2 = {} + for k, v in d.items(): + if k in names: + continue + d2[k] = f(v) + return d2 + return d + + +def instructions_to_str(instructions): + + s = [] + + for i in instructions: + v = i.to_jsondict()[i.__class__.__name__] + t = UTIL.ofp_instruction_type_to_user(v['type']) + inst_type = t if t != v['type'] else 'UNKNOWN' + # apply/write/clear-action instruction + if isinstance(i, ofproto_v1_4_parser.OFPInstructionActions): + acts = [] + for a in i.actions: + acts.append(action_to_str(a)) + v['type'] = inst_type + v['actions'] = acts + s.append(v) + # others + else: + v['type'] = inst_type + s.append(v) + + return s + + +def to_match(dp, attrs): + convert = {'in_port': UTIL.ofp_port_from_user, + 'in_phy_port': int, + 'metadata': to_match_masked_int, + 'eth_dst': to_match_eth, + 'eth_src': to_match_eth, + 'eth_type': int, + 'vlan_vid': to_match_vid, + 'vlan_pcp': int, + 'ip_dscp': int, + 'ip_ecn': int, + 'ip_proto': int, + 'ipv4_src': to_match_ip, + 'ipv4_dst': to_match_ip, + 'tcp_src': int, + 'tcp_dst': int, + 'udp_src': int, + 'udp_dst': int, + 'sctp_src': int, + 'sctp_dst': int, + 'icmpv4_type': int, + 'icmpv4_code': int, + 'arp_op': int, + 'arp_spa': to_match_ip, + 'arp_tpa': to_match_ip, + 'arp_sha': to_match_eth, + 'arp_tha': to_match_eth, + 'ipv6_src': to_match_ip, + 'ipv6_dst': to_match_ip, + 'ipv6_flabel': int, + 'icmpv6_type': int, + 'icmpv6_code': int, + 'ipv6_nd_target': to_match_ip, + 'ipv6_nd_sll': to_match_eth, + 'ipv6_nd_tll': to_match_eth, + 'mpls_label': int, + 'mpls_tc': int, + 'mpls_bos': int, + 'pbb_isid': to_match_masked_int, + 'tunnel_id': to_match_masked_int, + 'ipv6_exthdr': to_match_masked_int} + + if attrs.get('eth_type') == ether.ETH_TYPE_ARP: + if 'ipv4_src' in attrs and 'arp_spa' not in attrs: + attrs['arp_spa'] = attrs['ipv4_src'] + del attrs['ipv4_src'] + if 'ipv4_dst' in attrs and 'arp_tpa' not in attrs: + attrs['arp_tpa'] = attrs['ipv4_dst'] + del attrs['ipv4_dst'] + + kwargs = {} + for key, value in attrs.items(): + if key in convert: + value = convert[key](value) + kwargs[key] = value + else: + LOG.error('Unknown match field: %s', key) + + return dp.ofproto_parser.OFPMatch(**kwargs) + + +def to_match_eth(value): + if '/' in value: + value = value.split('/') + return value[0], value[1] + else: + return value + + +def to_match_ip(value): + if '/' in value: + (ip_addr, ip_mask) = value.split('/') + if ip_mask.isdigit(): + ip = netaddr.ip.IPNetwork(value) + ip_addr = str(ip.ip) + ip_mask = str(ip.netmask) + return ip_addr, ip_mask + else: + return value + + +def to_match_vid(value): + # NOTE: If "vlan_id" field is described as decimal int value + # (and decimal string value), it is treated as values of + # VLAN tag, and OFPVID_PRESENT(0x1000) bit is automatically + # applied. OTOH, If it is described as hexadecimal string, + # treated as values of oxm_value (including OFPVID_PRESENT + # bit), and OFPVID_PRESENT bit is NOT automatically applied. + if isinstance(value, six.integer_types): + # described as decimal int value + return value | ofproto_v1_4.OFPVID_PRESENT + else: + if '/' in value: + val = value.split('/') + return int(val[0], 0), int(val[1], 0) + else: + if value.isdigit(): + # described as decimal string value + return int(value, 10) | ofproto_v1_4.OFPVID_PRESENT + else: + return int(value, 0) + + +def to_match_masked_int(value): + if isinstance(value, str) and '/' in value: + value = value.split('/') + return (ofctl_utils.str_to_int(value[0]), + ofctl_utils.str_to_int(value[1])) + else: + return ofctl_utils.str_to_int(value) + + +def match_to_str(ofmatch): + match = {} + + ofmatch = ofmatch.to_jsondict()['OFPMatch'] + ofmatch = ofmatch['oxm_fields'] + + for match_field in ofmatch: + key = match_field['OXMTlv']['field'] + mask = match_field['OXMTlv']['mask'] + value = match_field['OXMTlv']['value'] + if key == 'vlan_vid': + value = match_vid_to_str(value, mask) + elif key == 'in_port': + value = UTIL.ofp_port_to_user(value) + else: + if mask is not None: + value = str(value) + '/' + str(mask) + match.setdefault(key, value) + + return match + + +def match_vid_to_str(value, mask): + if mask is not None: + value = '0x%04x/0x%04x' % (value, mask) + else: + if value & ofproto_v1_4.OFPVID_PRESENT: + value = str(value & ~ofproto_v1_4.OFPVID_PRESENT) + else: + value = '0x%04x' % value + return value + + +def send_stats_request(dp, stats, waiters, msgs): + dp.set_xid(stats) + waiters_per_dp = waiters.setdefault(dp.id, {}) + lock = hub.Event() + previous_msg_len = len(msgs) + waiters_per_dp[stats.xid] = (lock, msgs) + dp.send_msg(stats) + + lock.wait(timeout=DEFAULT_TIMEOUT) + current_msg_len = len(msgs) + + while current_msg_len > previous_msg_len: + previous_msg_len = current_msg_len + lock.wait(timeout=DEFAULT_TIMEOUT) + current_msg_len = len(msgs) + + if not lock.is_set(): + del waiters_per_dp[stats.xid] + + +def get_desc_stats(dp, waiters): + stats = dp.ofproto_parser.OFPDescStatsRequest(dp, 0) + msgs = [] + send_stats_request(dp, stats, waiters, msgs) + s = {} + + for msg in msgs: + stats = msg.body + s = stats.to_jsondict()[stats.__class__.__name__] + desc = {str(dp.id): s} + return desc + + +def get_queue_stats(dp, waiters): + ofp = dp.ofproto + stats = dp.ofproto_parser.OFPQueueStatsRequest(dp, 0, ofp.OFPP_ANY, + ofp.OFPQ_ALL) + msgs = [] + send_stats_request(dp, stats, waiters, msgs) + + desc = [] + for msg in msgs: + stats = msg.body + for stat in stats: + s = stat.to_jsondict()[stat.__class__.__name__] + properties = [] + for prop in stat.properties: + p = prop.to_jsondict()[prop.__class__.__name__] + t = UTIL.ofp_queue_stats_prop_type_to_user(prop.type) + p['type'] = t if t != p['type'] else 'UNKNOWN' + properties.append(p) + s['properties'] = properties + desc.append(s) + desc = {str(dp.id): desc} + return desc + + +def get_queue_desc_stats(dp, waiters, port_no=None, queue_id=None): + ofp = dp.ofproto + port_no = port_no if port_no else ofp.OFPP_ANY + queue_id = queue_id if queue_id else ofp.OFPQ_ALL + + stats = dp.ofproto_parser.OFPQueueDescStatsRequest( + dp, 0, port_no, queue_id) + msgs = [] + send_stats_request(dp, stats, waiters, msgs) + + configs = [] + for config in msgs: + queue_list = [] + for queue in config.body: + q = queue.to_jsondict()[queue.__class__.__name__] + prop_list = [] + for prop in queue.properties: + p = prop.to_jsondict()[prop.__class__.__name__] + t = UTIL.ofp_queue_desc_prop_type_to_user(prop.type) + p['type'] = t if t != prop.type else 'UNKNOWN' + prop_list.append(p) + q['properties'] = prop_list + queue_list.append(q) + c = {'body': queue_list} + configs.append(c) + configs = {str(dp.id): configs} + + return configs + + +def get_flow_stats(dp, waiters, flow=None): + flow = flow if flow else {} + table_id = UTIL.ofp_table_from_user( + flow.get('table_id', dp.ofproto.OFPTT_ALL)) + flags = int(flow.get('flags', 0)) + out_port = UTIL.ofp_port_from_user( + flow.get('out_port', dp.ofproto.OFPP_ANY)) + out_group = UTIL.ofp_group_from_user( + flow.get('out_group', dp.ofproto.OFPG_ANY)) + cookie = int(flow.get('cookie', 0)) + cookie_mask = int(flow.get('cookie_mask', 0)) + match = to_match(dp, flow.get('match', {})) + + stats = dp.ofproto_parser.OFPFlowStatsRequest( + dp, flags, table_id, out_port, out_group, cookie, cookie_mask, + match) + + msgs = [] + send_stats_request(dp, stats, waiters, msgs) + + flows = [] + for msg in msgs: + for stats in msg.body: + s = stats.to_jsondict()[stats.__class__.__name__] + s['instructions'] = instructions_to_str(stats.instructions) + s['match'] = match_to_str(stats.match) + flows.append(s) + flows = {str(dp.id): flows} + + return flows + + +def get_aggregate_flow_stats(dp, waiters, flow=None): + flow = flow if flow else {} + table_id = UTIL.ofp_table_from_user( + flow.get('table_id', dp.ofproto.OFPTT_ALL)) + flags = int(flow.get('flags', 0)) + out_port = UTIL.ofp_port_from_user( + flow.get('out_port', dp.ofproto.OFPP_ANY)) + out_group = UTIL.ofp_group_from_user( + flow.get('out_group', dp.ofproto.OFPG_ANY)) + cookie = int(flow.get('cookie', 0)) + cookie_mask = int(flow.get('cookie_mask', 0)) + match = to_match(dp, flow.get('match', {})) + + stats = dp.ofproto_parser.OFPAggregateStatsRequest( + dp, flags, table_id, out_port, out_group, cookie, cookie_mask, + match) + + msgs = [] + send_stats_request(dp, stats, waiters, msgs) + + flows = [] + for msg in msgs: + stats = msg.body + s = stats.to_jsondict()[stats.__class__.__name__] + flows.append(s) + flows = {str(dp.id): flows} + + return flows + + +def get_table_stats(dp, waiters): + stats = dp.ofproto_parser.OFPTableStatsRequest(dp, 0) + msgs = [] + send_stats_request(dp, stats, waiters, msgs) + + tables = [] + for msg in msgs: + stats = msg.body + for stat in stats: + s = stat.to_jsondict()[stat.__class__.__name__] + tables.append(s) + desc = {str(dp.id): tables} + + return desc + + +def get_table_features(dp, waiters): + stats = dp.ofproto_parser.OFPTableFeaturesStatsRequest(dp, 0, []) + msgs = [] + ofproto = dp.ofproto + send_stats_request(dp, stats, waiters, msgs) + + p_type_instructions = [ofproto.OFPTFPT_INSTRUCTIONS, + ofproto.OFPTFPT_INSTRUCTIONS_MISS] + + p_type_next_tables = [ofproto.OFPTFPT_NEXT_TABLES, + ofproto.OFPTFPT_NEXT_TABLES_MISS] + + p_type_actions = [ofproto.OFPTFPT_WRITE_ACTIONS, + ofproto.OFPTFPT_WRITE_ACTIONS_MISS, + ofproto.OFPTFPT_APPLY_ACTIONS, + ofproto.OFPTFPT_APPLY_ACTIONS_MISS] + + p_type_oxms = [ofproto.OFPTFPT_MATCH, + ofproto.OFPTFPT_WILDCARDS, + ofproto.OFPTFPT_WRITE_SETFIELD, + ofproto.OFPTFPT_WRITE_SETFIELD_MISS, + ofproto.OFPTFPT_APPLY_SETFIELD, + ofproto.OFPTFPT_APPLY_SETFIELD_MISS] + + p_type_experimenter = [ofproto.OFPTFPT_EXPERIMENTER, + ofproto.OFPTFPT_EXPERIMENTER_MISS] + + tables = [] + for msg in msgs: + stats = msg.body + for stat in stats: + s = stat.to_jsondict()[stat.__class__.__name__] + properties = [] + for prop in stat.properties: + p = {} + t = UTIL.ofp_table_feature_prop_type_to_user(prop.type) + p['type'] = t if t != prop.type else 'UNKNOWN' + if prop.type in p_type_instructions: + instruction_ids = [] + for id in prop.instruction_ids: + i = {'len': id.len, + 'type': id.type} + instruction_ids.append(i) + p['instruction_ids'] = instruction_ids + elif prop.type in p_type_next_tables: + table_ids = [] + for id in prop.table_ids: + table_ids.append(id) + p['table_ids'] = table_ids + elif prop.type in p_type_actions: + action_ids = [] + for id in prop.action_ids: + i = id.to_jsondict()[id.__class__.__name__] + action_ids.append(i) + p['action_ids'] = action_ids + elif prop.type in p_type_oxms: + oxm_ids = [] + for id in prop.oxm_ids: + i = id.to_jsondict()[id.__class__.__name__] + oxm_ids.append(i) + p['oxm_ids'] = oxm_ids + elif prop.type in p_type_experimenter: + pass + properties.append(p) + s['name'] = stat.name.decode('utf-8') + s['properties'] = properties + tables.append(s) + desc = {str(dp.id): tables} + + return desc + + +def get_port_stats(dp, waiters): + stats = dp.ofproto_parser.OFPPortStatsRequest( + dp, 0, dp.ofproto.OFPP_ANY) + msgs = [] + send_stats_request(dp, stats, waiters, msgs) + + ports = [] + for msg in msgs: + for stats in msg.body: + s = stats.to_jsondict()[stats.__class__.__name__] + properties = [] + for prop in stats.properties: + p = prop.to_jsondict()[prop.__class__.__name__] + t = UTIL.ofp_port_stats_prop_type_to_user(prop.type) + p['type'] = t if t != prop.type else 'UNKNOWN' + properties.append(p) + s['properties'] = properties + ports.append(s) + ports = {str(dp.id): ports} + return ports + + +def get_meter_stats(dp, waiters): + stats = dp.ofproto_parser.OFPMeterStatsRequest( + dp, 0, dp.ofproto.OFPM_ALL) + msgs = [] + send_stats_request(dp, stats, waiters, msgs) + + meters = [] + for msg in msgs: + for stats in msg.body: + s = stats.to_jsondict()[stats.__class__.__name__] + bands = [] + for band in stats.band_stats: + b = band.to_jsondict()[band.__class__.__name__] + bands.append(b) + s['band_stats'] = bands + meters.append(s) + meters = {str(dp.id): meters} + return meters + + +def get_meter_features(dp, waiters): + ofp = dp.ofproto + type_convert = {ofp.OFPMBT_DROP: 'DROP', + ofp.OFPMBT_DSCP_REMARK: 'DSCP_REMARK'} + + capa_convert = {ofp.OFPMF_KBPS: 'KBPS', + ofp.OFPMF_PKTPS: 'PKTPS', + ofp.OFPMF_BURST: 'BURST', + ofp.OFPMF_STATS: 'STATS'} + + stats = dp.ofproto_parser.OFPMeterFeaturesStatsRequest(dp, 0) + msgs = [] + send_stats_request(dp, stats, waiters, msgs) + + features = [] + for msg in msgs: + for feature in msg.body: + band_types = [] + for k, v in type_convert.items(): + if (1 << k) & feature.band_types: + band_types.append(v) + capabilities = [] + for k, v in sorted(capa_convert.items()): + if k & feature.capabilities: + capabilities.append(v) + f = {'max_meter': feature.max_meter, + 'band_types': band_types, + 'capabilities': capabilities, + 'max_bands': feature.max_bands, + 'max_color': feature.max_color} + features.append(f) + features = {str(dp.id): features} + return features + + +def get_meter_config(dp, waiters): + flags = {dp.ofproto.OFPMF_KBPS: 'KBPS', + dp.ofproto.OFPMF_PKTPS: 'PKTPS', + dp.ofproto.OFPMF_BURST: 'BURST', + dp.ofproto.OFPMF_STATS: 'STATS'} + + stats = dp.ofproto_parser.OFPMeterConfigStatsRequest( + dp, 0, dp.ofproto.OFPM_ALL) + msgs = [] + send_stats_request(dp, stats, waiters, msgs) + + configs = [] + for msg in msgs: + for config in msg.body: + c = config.to_jsondict()[config.__class__.__name__] + bands = [] + for band in config.bands: + b = band.to_jsondict()[band.__class__.__name__] + t = UTIL.ofp_meter_band_type_to_user(band.type) + b['type'] = t if t != band.type else 'UNKNOWN' + bands.append(b) + c_flags = [] + for k, v in sorted(flags.items()): + if k & config.flags: + c_flags.append(v) + c['flags'] = c_flags + c['bands'] = bands + configs.append(c) + configs = {str(dp.id): configs} + return configs + + +def get_group_stats(dp, waiters): + stats = dp.ofproto_parser.OFPGroupStatsRequest( + dp, 0, dp.ofproto.OFPG_ALL) + msgs = [] + send_stats_request(dp, stats, waiters, msgs) + + groups = [] + for msg in msgs: + for stats in msg.body: + g = stats.to_jsondict()[stats.__class__.__name__] + bucket_stats = [] + for bucket_stat in stats.bucket_stats: + c = bucket_stat.to_jsondict()[bucket_stat.__class__.__name__] + bucket_stats.append(c) + g['bucket_stats'] = bucket_stats + groups.append(g) + groups = {str(dp.id): groups} + return groups + + +def get_group_features(dp, waiters): + + ofp = dp.ofproto + type_convert = {ofp.OFPGT_ALL: 'ALL', + ofp.OFPGT_SELECT: 'SELECT', + ofp.OFPGT_INDIRECT: 'INDIRECT', + ofp.OFPGT_FF: 'FF'} + cap_convert = {ofp.OFPGFC_SELECT_WEIGHT: 'SELECT_WEIGHT', + ofp.OFPGFC_SELECT_LIVENESS: 'SELECT_LIVENESS', + ofp.OFPGFC_CHAINING: 'CHAINING', + ofp.OFPGFC_CHAINING_CHECKS: 'CHAINING_CHECKS'} + act_convert = {ofp.OFPAT_OUTPUT: 'OUTPUT', + ofp.OFPAT_COPY_TTL_OUT: 'COPY_TTL_OUT', + ofp.OFPAT_COPY_TTL_IN: 'COPY_TTL_IN', + ofp.OFPAT_SET_MPLS_TTL: 'SET_MPLS_TTL', + ofp.OFPAT_DEC_MPLS_TTL: 'DEC_MPLS_TTL', + ofp.OFPAT_PUSH_VLAN: 'PUSH_VLAN', + ofp.OFPAT_POP_VLAN: 'POP_VLAN', + ofp.OFPAT_PUSH_MPLS: 'PUSH_MPLS', + ofp.OFPAT_POP_MPLS: 'POP_MPLS', + ofp.OFPAT_SET_QUEUE: 'SET_QUEUE', + ofp.OFPAT_GROUP: 'GROUP', + ofp.OFPAT_SET_NW_TTL: 'SET_NW_TTL', + ofp.OFPAT_DEC_NW_TTL: 'DEC_NW_TTL', + ofp.OFPAT_SET_FIELD: 'SET_FIELD', + ofp.OFPAT_PUSH_PBB: 'PUSH_PBB', + ofp.OFPAT_POP_PBB: 'POP_PBB', + ofp.OFPAT_EXPERIMENTER: 'EXPERIMENTER', + } + + stats = dp.ofproto_parser.OFPGroupFeaturesStatsRequest(dp, 0) + msgs = [] + send_stats_request(dp, stats, waiters, msgs) + + features = [] + for msg in msgs: + feature = msg.body + types = [] + for k, v in type_convert.items(): + if (1 << k) & feature.types: + types.append(v) + capabilities = [] + for k, v in cap_convert.items(): + if k & feature.capabilities: + capabilities.append(v) + max_groups = [] + for k, v in type_convert.items(): + max_groups.append({v: feature.max_groups[k]}) + actions = [] + for k1, v1 in type_convert.items(): + acts = [] + for k2, v2 in act_convert.items(): + if (1 << k2) & feature.actions[k1]: + acts.append(v2) + actions.append({v1: acts}) + f = {'types': types, + 'capabilities': capabilities, + 'max_groups': max_groups, + 'actions': actions} + features.append(f) + features = {str(dp.id): features} + return features + + +def get_group_desc(dp, waiters): + stats = dp.ofproto_parser.OFPGroupDescStatsRequest(dp, 0) + msgs = [] + send_stats_request(dp, stats, waiters, msgs) + + descs = [] + for msg in msgs: + for stats in msg.body: + d = stats.to_jsondict()[stats.__class__.__name__] + buckets = [] + for bucket in stats.buckets: + b = bucket.to_jsondict()[bucket.__class__.__name__] + actions = [] + for action in bucket.actions: + actions.append(action_to_str(action)) + b['actions'] = actions + buckets.append(b) + t = UTIL.ofp_group_type_to_user(stats.type) + d['type'] = t if t != stats.type else 'UNKNOWN' + d['buckets'] = buckets + descs.append(d) + descs = {str(dp.id): descs} + return descs + + +def get_port_desc(dp, waiters): + stats = dp.ofproto_parser.OFPPortDescStatsRequest(dp, 0) + msgs = [] + send_stats_request(dp, stats, waiters, msgs) + + descs = [] + + for msg in msgs: + stats = msg.body + for stat in stats: + d = stat.to_jsondict()[stat.__class__.__name__] + properties = [] + for prop in stat.properties: + p = prop.to_jsondict()[prop.__class__.__name__] + t = UTIL.ofp_port_desc_prop_type_to_user(prop.type) + p['type'] = t if t != prop.type else 'UNKNOWN' + properties.append(p) + d['name'] = stat.name.decode('utf-8') + d['properties'] = properties + descs.append(d) + descs = {str(dp.id): descs} + return descs + + +def mod_flow_entry(dp, flow, cmd): + cookie = int(flow.get('cookie', 0)) + cookie_mask = int(flow.get('cookie_mask', 0)) + table_id = UTIL.ofp_table_from_user(flow.get('table_id', 0)) + idle_timeout = int(flow.get('idle_timeout', 0)) + hard_timeout = int(flow.get('hard_timeout', 0)) + priority = int(flow.get('priority', 0)) + buffer_id = UTIL.ofp_buffer_from_user( + flow.get('buffer_id', dp.ofproto.OFP_NO_BUFFER)) + out_port = UTIL.ofp_port_from_user( + flow.get('out_port', dp.ofproto.OFPP_ANY)) + out_group = UTIL.ofp_group_from_user( + flow.get('out_group', dp.ofproto.OFPG_ANY)) + importance = int(flow.get('importance', 0)) + flags = int(flow.get('flags', 0)) + match = to_match(dp, flow.get('match', {})) + inst = to_instructions(dp, flow.get('instructions', [])) + + flow_mod = dp.ofproto_parser.OFPFlowMod( + dp, cookie, cookie_mask, table_id, cmd, idle_timeout, + hard_timeout, priority, buffer_id, out_port, out_group, + importance, flags, match, inst) + + dp.send_msg(flow_mod) + + +def mod_meter_entry(dp, meter, cmd): + flags = 0 + if 'flags' in meter: + meter_flags = meter['flags'] + if not isinstance(meter_flags, list): + meter_flags = [meter_flags] + for flag in meter_flags: + t = UTIL.ofp_meter_flags_from_user(flag) + f = t if t != flag else None + if f is None: + LOG.error('Unknown meter flag: %s', flag) + continue + flags |= f + + meter_id = UTIL.ofp_meter_from_user(meter.get('meter_id', 0)) + + bands = [] + for band in meter.get('bands', []): + band_type = band.get('type') + rate = int(band.get('rate', 0)) + burst_size = int(band.get('burst_size', 0)) + if band_type == 'DROP': + b = dp.ofproto_parser.OFPMeterBandDrop(rate, burst_size) + elif band_type == 'DSCP_REMARK': + prec_level = int(band.get('prec_level', 0)) + b = dp.ofproto_parser.OFPMeterBandDscpRemark( + rate, burst_size, prec_level) + elif band_type == 'EXPERIMENTER': + experimenter = int(band.get('experimenter', 0)) + b = dp.ofproto_parser.OFPMeterBandExperimenter( + rate, burst_size, experimenter) + else: + LOG.error('Unknown band type: %s', band_type) + continue + bands.append(b) + + meter_mod = dp.ofproto_parser.OFPMeterMod( + dp, cmd, flags, meter_id, bands) + + dp.send_msg(meter_mod) + + +def mod_group_entry(dp, group, cmd): + group_type = str(group.get('type')) + t = UTIL.ofp_group_type_from_user(group_type) + group_type = t if t != group_type else None + if group_type is None: + LOG.error('Unknown group type: %s', group.get('type')) + + group_id = UTIL.ofp_group_from_user(group.get('group_id', 0)) + + buckets = [] + for bucket in group.get('buckets', []): + weight = int(bucket.get('weight', 0)) + watch_port = int(bucket.get('watch_port', dp.ofproto.OFPP_ANY)) + watch_group = int(bucket.get('watch_group', dp.ofproto.OFPG_ANY)) + actions = [] + for dic in bucket.get('actions', []): + action = to_action(dp, dic) + if action is not None: + actions.append(action) + b = dp.ofproto_parser.OFPBucket( + weight, watch_port, watch_group, actions) + buckets.append(b) + + group_mod = dp.ofproto_parser.OFPGroupMod( + dp, cmd, group_type, group_id, buckets) + + dp.send_msg(group_mod) + + +def mod_port_behavior(dp, port_config): + ofp = dp.ofproto + parser = dp.ofproto_parser + port_no = UTIL.ofp_port_from_user(port_config.get('port_no', 0)) + hw_addr = str(port_config.get('hw_addr')) + config = int(port_config.get('config', 0)) + mask = int(port_config.get('mask', 0)) + properties = port_config.get('properties') + + prop = [] + for p in properties: + type_ = UTIL.ofp_port_mod_prop_type_from_user(p['type']) + length = None + if type_ == ofp.OFPPDPT_ETHERNET: + advertise = UTIL.ofp_port_features_from_user(p['advertise']) + m = parser.OFPPortModPropEthernet(type_, length, + advertise) + elif type_ == ofp.OFPPDPT_OPTICAL: + m = parser.OFPPortModPropOptical(type_, length, + p['configure'], + p['freq_lmda'], + p['fl_offset'], + p['grid_span'], + p['tx_pwr']) + elif type_ == ofp.OFPPDPT_EXPERIMENTER: + m = parser.OFPPortModPropExperimenter(type_, length, + p['experimenter'], + p['exp_type'], + p['data']) + else: + LOG.error('Unknown port desc prop type: %s', type_) + continue + prop.append(m) + + port_mod = dp.ofproto_parser.OFPPortMod( + dp, port_no, hw_addr, config, mask, prop) + + dp.send_msg(port_mod) + + +def send_experimenter(dp, exp): + experimenter = exp.get('experimenter', 0) + exp_type = exp.get('exp_type', 0) + data_type = exp.get('data_type', 'ascii') + if data_type != 'ascii' and data_type != 'base64': + LOG.error('Unknown data type: %s', data_type) + data = exp.get('data', '') + if data_type == 'base64': + data = base64.b64decode(data) + + expmsg = dp.ofproto_parser.OFPExperimenter( + dp, experimenter, exp_type, data) + + dp.send_msg(expmsg)