| #!/usr/bin/env python3 |
| # SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause |
| |
| import argparse |
| import json |
| import os |
| import pathlib |
| import pprint |
| import sys |
| import textwrap |
| |
| sys.path.append(pathlib.Path(__file__).resolve().parent.as_posix()) |
| from lib import YnlFamily, Netlink, NlError, SpecFamily |
| |
| sys_schema_dir='/usr/share/ynl' |
| relative_schema_dir='../../../../Documentation/netlink' |
| |
| def schema_dir(): |
| script_dir = os.path.dirname(os.path.abspath(__file__)) |
| schema_dir = os.path.abspath(f"{script_dir}/{relative_schema_dir}") |
| if not os.path.isdir(schema_dir): |
| schema_dir = sys_schema_dir |
| if not os.path.isdir(schema_dir): |
| raise Exception(f"Schema directory {schema_dir} does not exist") |
| return schema_dir |
| |
| def spec_dir(): |
| spec_dir = schema_dir() + '/specs' |
| if not os.path.isdir(spec_dir): |
| raise Exception(f"Spec directory {spec_dir} does not exist") |
| return spec_dir |
| |
| |
| class YnlEncoder(json.JSONEncoder): |
| def default(self, obj): |
| if isinstance(obj, bytes): |
| return bytes.hex(obj) |
| if isinstance(obj, set): |
| return list(obj) |
| return json.JSONEncoder.default(self, obj) |
| |
| |
| def print_attr_list(ynl, attr_names, attr_set, indent=2): |
| """Print a list of attributes with their types and documentation.""" |
| prefix = ' ' * indent |
| for attr_name in attr_names: |
| if attr_name in attr_set.attrs: |
| attr = attr_set.attrs[attr_name] |
| attr_info = f'{prefix}- {attr_name}: {attr.type}' |
| if 'enum' in attr.yaml: |
| enum_name = attr.yaml['enum'] |
| attr_info += f" (enum: {enum_name})" |
| # Print enum values if available |
| if enum_name in ynl.consts: |
| const = ynl.consts[enum_name] |
| enum_values = list(const.entries.keys()) |
| attr_info += f"\n{prefix} {const.type.capitalize()}: {', '.join(enum_values)}" |
| |
| # Show nested attributes reference and recursively display them |
| nested_set_name = None |
| if attr.type == 'nest' and 'nested-attributes' in attr.yaml: |
| nested_set_name = attr.yaml['nested-attributes'] |
| attr_info += f" -> {nested_set_name}" |
| |
| if attr.yaml.get('doc'): |
| doc_text = textwrap.indent(attr.yaml['doc'], prefix + ' ') |
| attr_info += f"\n{doc_text}" |
| print(attr_info) |
| |
| # Recursively show nested attributes |
| if nested_set_name in ynl.attr_sets: |
| nested_set = ynl.attr_sets[nested_set_name] |
| # Filter out 'unspec' and other unused attrs |
| nested_names = [n for n in nested_set.attrs.keys() |
| if nested_set.attrs[n].type != 'unused'] |
| if nested_names: |
| print_attr_list(ynl, nested_names, nested_set, indent + 4) |
| |
| |
| def print_mode_attrs(ynl, mode, mode_spec, attr_set, print_request=True): |
| """Print a given mode (do/dump/event/notify).""" |
| mode_title = mode.capitalize() |
| |
| if print_request and 'request' in mode_spec and 'attributes' in mode_spec['request']: |
| print(f'\n{mode_title} request attributes:') |
| print_attr_list(ynl, mode_spec['request']['attributes'], attr_set) |
| |
| if 'reply' in mode_spec and 'attributes' in mode_spec['reply']: |
| print(f'\n{mode_title} reply attributes:') |
| print_attr_list(ynl, mode_spec['reply']['attributes'], attr_set) |
| |
| if 'attributes' in mode_spec: |
| print(f'\n{mode_title} attributes:') |
| print_attr_list(ynl, mode_spec['attributes'], attr_set) |
| |
| |
| def main(): |
| description = """ |
| YNL CLI utility - a general purpose netlink utility that uses YAML |
| specs to drive protocol encoding and decoding. |
| """ |
| epilog = """ |
| The --multi option can be repeated to include several do operations |
| in the same netlink payload. |
| """ |
| |
| parser = argparse.ArgumentParser(description=description, |
| epilog=epilog) |
| spec_group = parser.add_mutually_exclusive_group(required=True) |
| spec_group.add_argument('--family', dest='family', type=str, |
| help='name of the netlink FAMILY') |
| spec_group.add_argument('--list-families', action='store_true', |
| help='list all netlink families supported by YNL (has spec)') |
| spec_group.add_argument('--spec', dest='spec', type=str, |
| help='choose the family by SPEC file path') |
| |
| parser.add_argument('--schema', dest='schema', type=str) |
| parser.add_argument('--no-schema', action='store_true') |
| parser.add_argument('--json', dest='json_text', type=str) |
| |
| group = parser.add_mutually_exclusive_group() |
| group.add_argument('--do', dest='do', metavar='DO-OPERATION', type=str) |
| group.add_argument('--multi', dest='multi', nargs=2, action='append', |
| metavar=('DO-OPERATION', 'JSON_TEXT'), type=str) |
| group.add_argument('--dump', dest='dump', metavar='DUMP-OPERATION', type=str) |
| group.add_argument('--list-ops', action='store_true') |
| group.add_argument('--list-msgs', action='store_true') |
| group.add_argument('--list-attrs', dest='list_attrs', metavar='OPERATION', type=str, |
| help='List attributes for an operation') |
| group.add_argument('--validate', action='store_true') |
| |
| parser.add_argument('--duration', dest='duration', type=int, |
| help='when subscribed, watch for DURATION seconds') |
| parser.add_argument('--sleep', dest='duration', type=int, |
| help='alias for duration') |
| parser.add_argument('--subscribe', dest='ntf', type=str) |
| parser.add_argument('--replace', dest='flags', action='append_const', |
| const=Netlink.NLM_F_REPLACE) |
| parser.add_argument('--excl', dest='flags', action='append_const', |
| const=Netlink.NLM_F_EXCL) |
| parser.add_argument('--create', dest='flags', action='append_const', |
| const=Netlink.NLM_F_CREATE) |
| parser.add_argument('--append', dest='flags', action='append_const', |
| const=Netlink.NLM_F_APPEND) |
| parser.add_argument('--process-unknown', action=argparse.BooleanOptionalAction) |
| parser.add_argument('--output-json', action='store_true') |
| parser.add_argument('--dbg-small-recv', default=0, const=4000, |
| action='store', nargs='?', type=int) |
| args = parser.parse_args() |
| |
| def output(msg): |
| if args.output_json: |
| print(json.dumps(msg, cls=YnlEncoder)) |
| else: |
| pprint.PrettyPrinter().pprint(msg) |
| |
| if args.list_families: |
| for filename in sorted(os.listdir(spec_dir())): |
| if filename.endswith('.yaml'): |
| print(filename.removesuffix('.yaml')) |
| return |
| |
| if args.no_schema: |
| args.schema = '' |
| |
| attrs = {} |
| if args.json_text: |
| attrs = json.loads(args.json_text) |
| |
| if args.family: |
| spec = f"{spec_dir()}/{args.family}.yaml" |
| else: |
| spec = args.spec |
| if not os.path.isfile(spec): |
| raise Exception(f"Spec file {spec} does not exist") |
| |
| if args.validate: |
| try: |
| SpecFamily(spec, args.schema) |
| except Exception as error: |
| print(error) |
| exit(1) |
| return |
| |
| if args.family: # set behaviour when using installed specs |
| if args.schema is None and spec.startswith(sys_schema_dir): |
| args.schema = '' # disable schema validation when installed |
| if args.process_unknown is None: |
| args.process_unknown = True |
| |
| ynl = YnlFamily(spec, args.schema, args.process_unknown, |
| recv_size=args.dbg_small_recv) |
| if args.dbg_small_recv: |
| ynl.set_recv_dbg(True) |
| |
| if args.ntf: |
| ynl.ntf_subscribe(args.ntf) |
| |
| if args.list_ops: |
| for op_name, op in ynl.ops.items(): |
| print(op_name, " [", ", ".join(op.modes), "]") |
| if args.list_msgs: |
| for op_name, op in ynl.msgs.items(): |
| print(op_name, " [", ", ".join(op.modes), "]") |
| |
| if args.list_attrs: |
| op = ynl.msgs.get(args.list_attrs) |
| if not op: |
| print(f'Operation {args.list_attrs} not found') |
| exit(1) |
| |
| print(f'Operation: {op.name}') |
| print(op.yaml['doc']) |
| |
| for mode in ['do', 'dump', 'event']: |
| if mode in op.yaml: |
| print_mode_attrs(ynl, mode, op.yaml[mode], op.attr_set, True) |
| |
| if 'notify' in op.yaml: |
| mode_spec = op.yaml['notify'] |
| ref_spec = ynl.msgs.get(mode_spec).yaml.get('do') |
| if ref_spec: |
| print_mode_attrs(ynl, 'notify', ref_spec, op.attr_set, False) |
| |
| if 'mcgrp' in op.yaml: |
| print(f"\nMulticast group: {op.yaml['mcgrp']}") |
| |
| try: |
| if args.do: |
| reply = ynl.do(args.do, attrs, args.flags) |
| output(reply) |
| if args.dump: |
| reply = ynl.dump(args.dump, attrs) |
| output(reply) |
| if args.multi: |
| ops = [ (item[0], json.loads(item[1]), args.flags or []) for item in args.multi ] |
| reply = ynl.do_multi(ops) |
| output(reply) |
| |
| if args.ntf: |
| for msg in ynl.poll_ntf(duration=args.duration): |
| output(msg) |
| except NlError as e: |
| print(e) |
| exit(1) |
| except KeyboardInterrupt: |
| pass |
| except BrokenPipeError: |
| pass |
| |
| |
| if __name__ == "__main__": |
| main() |
