| # Copyright 2017-present Open Networking Foundation |
| # |
| # 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 os |
| import sys |
| import requests |
| from termcolor import cprint, colored |
| from os.path import join as pjoin |
| |
| |
| def p_cookie(cookie): |
| cookie = str(cookie) |
| if len(cookie) > 8: |
| return cookie[:6] + '...' |
| else: |
| return cookie |
| |
| ''' |
| OFPP_NORMAL = 0x7ffffffa; /* Forward using non-OpenFlow pipeline. */ |
| OFPP_FLOOD = 0x7ffffffb; /* Flood using non-OpenFlow pipeline. */ |
| OFPP_ALL = 0x7ffffffc; /* All standard ports except input port. */ |
| OFPP_CONTROLLER = 0x7ffffffd; /* Send to controller. */ |
| OFPP_LOCAL = 0x7ffffffe; /* Local openflow "port". */ |
| OFPP_ANY = 0x7fffffff; /* Special value used in some requests when |
| ''' |
| |
| |
| def p_port(port): |
| if port & 0x7fffffff == 0x7ffffffa: |
| return 'NORMAL' |
| elif port & 0x7fffffff == 0x7ffffffb: |
| return 'FLOOD' |
| elif port & 0x7fffffff == 0x7ffffffc: |
| return 'ALL' |
| elif port & 0x7fffffff == 0x7ffffffd: |
| return 'CONTROLLER' |
| elif port & 0x7fffffff == 0x7ffffffe: |
| return 'LOCAL' |
| elif port & 0x7fffffff == 0x7fffffff: |
| return 'ANY' |
| else: |
| return str(port) |
| |
| |
| def p_vlan_vid(vlan_vid): |
| if vlan_vid == 0: |
| return 'untagged' |
| assert vlan_vid & 4096 == 4096 |
| return str(vlan_vid - 4096) |
| |
| |
| def p_ipv4(x): |
| return '.'.join(str(v) for v in [ |
| (x >> 24) & 0xff, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff |
| ]) |
| |
| |
| field_printers = { |
| 'IN_PORT': lambda f: (100, 'in_port', p_port(f['port'])), |
| 'VLAN_VID': lambda f: (101, 'vlan_vid', p_vlan_vid(f['vlan_vid'])), |
| 'VLAN_PCP': lambda f: (102, 'vlan_pcp', str(f['vlan_pcp'])), |
| 'ETH_TYPE': lambda f: (103, 'eth_type', '%X' % f['eth_type']), |
| 'IPV4_DST': lambda f: (104, 'ipv4_dst', p_ipv4(f['ipv4_dst'])), |
| 'IP_PROTO': lambda f: (105, 'ip_proto', str(f['ip_proto'])) |
| } |
| |
| |
| def p_field(field): |
| assert field['oxm_class'].endswith('OPENFLOW_BASIC') |
| ofb = field['ofb_field'] |
| assert not ofb['has_mask'] |
| type = ofb['type'][len('OFPXMT_OFB_'):] |
| weight, field_name, value = field_printers[type](ofb) |
| return 1000 + weight, 'set_' + field_name, value |
| |
| |
| action_printers = { |
| 'SET_FIELD': lambda a: p_field(a['set_field']['field']), |
| 'POP_VLAN': lambda a: (2000, 'pop_vlan', 'Yes'), |
| 'PUSH_VLAN': lambda a: (2001, 'push_vlan', '%x' % a['push']['ethertype']), |
| 'GROUP': lambda a: (3000, 'group', p_port(a['group']['group_id'])), |
| 'OUTPUT': lambda a: (4000, 'output', p_port(a['output']['port'])), |
| } |
| |
| |
| class ScriptBase(object): |
| |
| usage = 'To be filled by derived class' |
| deep_header = {'get-depth': '-1'} |
| |
| def __init__(self): |
| self.voltha_base_url = os.environ.get('VOLTHA_BASE_URL') |
| if self.voltha_base_url is None: |
| self.err(1) |
| |
| def err(self, code, msg=None): |
| if msg is None: |
| msg = self.usage |
| print >> sys.stderr, msg |
| sys.exit(code) |
| |
| def fetch_logical_device_info(self, base_url, logical_device_id): |
| url = pjoin(base_url, 'logical_devices', logical_device_id) |
| res = requests.get(url, headers=self.deep_header) |
| if res.ok: |
| return res.json() |
| else: |
| self.err('could not fetch logical device at {}: {}'.format( |
| url, res.text)) |
| |
| def fetch_device_info(self, base_url, device_id): |
| url = pjoin(base_url, 'devices', device_id) |
| res = requests.get(url, headers=self.deep_header) |
| if res.ok: |
| return res.json() |
| else: |
| self.err('could not fetch device at {}: {}'.format(url, res.text)) |
| |
| def print_flows(self, what, id, type, flows, groups): |
| |
| print |
| print ''.join([ |
| '{} '.format(what), |
| colored(id, color='green', attrs=['bold']), |
| ' (type: ', |
| colored(type, color='blue'), |
| ')' |
| ]) |
| print 'Flows:' |
| |
| max_field_lengths = {} |
| field_names = {} |
| |
| def update_max_length(field_key, string): |
| length = len(string) |
| if length > max_field_lengths.get(field_key, 0): |
| max_field_lengths[field_key] = length |
| |
| def add_field_type(field_key, field_name): |
| if field_key not in field_names: |
| field_names[field_key] = field_name |
| update_max_length(field_key, field_name) |
| else: |
| assert field_names[field_key] == field_name |
| |
| cell_values = {} |
| |
| # preprocess data |
| for i, flow in enumerate(flows): |
| |
| def add_field(field_key, field_name, value): |
| add_field_type(field_key, field_name) |
| row = cell_values.setdefault(i, {}) |
| row[field_key] = value |
| update_max_length(field_key, value) |
| |
| add_field(0, 'table_id', value=str(flow['table_id'])) |
| add_field(1, 'priority', value=str(flow['priority'])) |
| add_field(2, 'cookie', p_cookie(flow['cookie'])) |
| |
| assert flow['match']['type'] == 'OFPMT_OXM' |
| for field in flow['match']['oxm_fields']: |
| assert field['oxm_class'].endswith('OPENFLOW_BASIC') |
| ofb = field['ofb_field'] |
| assert not ofb['has_mask'], 'masked match not handled yet' # TODO |
| type = ofb['type'][len('OFPXMT_OFB_'):] |
| add_field(*field_printers[type](ofb)) |
| |
| for instruction in flow['instructions']: |
| if instruction['type'] == 4: |
| for action in instruction['actions']['actions']: |
| type = action['type'][len('OFPAT_'):] |
| add_field(*action_printers[type](action)) |
| |
| # print header |
| field_keys = sorted(field_names.keys()) |
| def p_sep(): |
| print '+' + '+'.join( |
| [(max_field_lengths[k] + 2) * '-' for k in field_keys]) + '+' |
| |
| p_sep() |
| print '| ' + ' | '.join( |
| '%%%ds' % max_field_lengths[k] % field_names[k] |
| for k in field_keys) + ' |' |
| p_sep() |
| |
| # print values |
| for i in xrange(len(flows)): |
| row = cell_values[i] |
| cprint('| ' + ' | '.join( |
| '%%%ds' % max_field_lengths[k] % row.get(k, '') |
| for k in field_keys |
| ) + ' |') |
| if not ((i + 1) % 3): |
| p_sep() |
| |
| if ((i + 1) % 3): |
| p_sep() |
| |
| # TODO groups TBF |
| assert len(groups) == 0 |
| |
| |