python/qemu/qmp/qom.py

   1 """
   2 QEMU Object Model testing tools.
   3
   4 usage: qom [-h] {set,get,list,tree} ...
   5
   6 Query and manipulate QOM data
   7
   8 optional arguments:
   9   -h, --help           show this help message and exit
  10
  11 QOM commands:
  12   {set,get,list,tree}
  13     set                Set a QOM property value
  14     get                Get a QOM property value
  15     list               List QOM properties at a given path
  16     tree               Show QOM tree from a given path
  17 """
  18 ##
  19 # Copyright John Snow 2020, for Red Hat, Inc.
  20 # Copyright IBM, Corp. 2011
  21 #
  22 # Authors:
  23 #  John Snow <jsnow@redhat.com>
  24 #  Anthony Liguori <aliguori@amazon.com>
  25 #
  26 # This work is licensed under the terms of the GNU GPL, version 2 or later.
  27 # See the COPYING file in the top-level directory.
  28 #
  29 # Based on ./scripts/qmp/qom-[set|get|tree|list]
  30 ##
  31
  32 import argparse
  33
  34 from . import QMPResponseError
  35 from .qom_common import QOMCommand
  36
  37
  38 class QOMSet(QOMCommand):
  39     """
  40     QOM Command - Set a property to a given value.
  41
  42     usage: qom-set [-h] [--socket SOCKET] <path>.<property> <value>
  43
  44     Set a QOM property value
  45
  46     positional arguments:
  47       <path>.<property>     QOM path and property, separated by a period '.'
  48       <value>               new QOM property value
  49
  50     optional arguments:
  51       -h, --help            show this help message and exit
  52       --socket SOCKET, -s SOCKET
  53                             QMP socket path or address (addr:port). May also be
  54                             set via QMP_SOCKET environment variable.
  55     """
  56     name = 'set'
  57     help = 'Set a QOM property value'
  58
  59     @classmethod
  60     def configure_parser(cls, parser: argparse.ArgumentParser) -> None:
  61         super().configure_parser(parser)
  62         cls.add_path_prop_arg(parser)
  63         parser.add_argument(
  64             'value',
  65             metavar='<value>',
  66             action='store',
  67             help='new QOM property value'
  68         )
  69
  70     def __init__(self, args: argparse.Namespace):
  71         super().__init__(args)
  72         self.path, self.prop = args.path_prop.rsplit('.', 1)
  73         self.value = args.value
  74
  75     def run(self) -> int:
  76         rsp = self.qmp.command(
  77             'qom-set',
  78             path=self.path,
  79             property=self.prop,
  80             value=self.value
  81         )
  82         print(rsp)
  83         return 0
  84
  85
  86 class QOMGet(QOMCommand):
  87     """
  88     QOM Command - Get a property's current value.
  89
  90     usage: qom-get [-h] [--socket SOCKET] <path>.<property>
  91
  92     Get a QOM property value
  93
  94     positional arguments:
  95       <path>.<property>     QOM path and property, separated by a period '.'
  96
  97     optional arguments:
  98       -h, --help            show this help message and exit
  99       --socket SOCKET, -s SOCKET
 100                             QMP socket path or address (addr:port). May also be
 101                             set via QMP_SOCKET environment variable.
 102     """
 103     name = 'get'
 104     help = 'Get a QOM property value'
 105
 106     @classmethod
 107     def configure_parser(cls, parser: argparse.ArgumentParser) -> None:
 108         super().configure_parser(parser)
 109         cls.add_path_prop_arg(parser)
 110
 111     def __init__(self, args: argparse.Namespace):
 112         super().__init__(args)
 113         try:
 114             tmp = args.path_prop.rsplit('.', 1)
 115         except ValueError as err:
 116             raise ValueError('Invalid format for <path>.<property>') from err
 117         self.path = tmp[0]
 118         self.prop = tmp[1]
 119
 120     def run(self) -> int:
 121         rsp = self.qmp.command(
 122             'qom-get',
 123             path=self.path,
 124             property=self.prop
 125         )
 126         if isinstance(rsp, dict):
 127             for key, value in rsp.items():
 128                 print(f"{key}: {value}")
 129         else:
 130             print(rsp)
 131         return 0
 132
 133
 134 class QOMList(QOMCommand):
 135     """
 136     QOM Command - List the properties at a given path.
 137
 138     usage: qom-list [-h] [--socket SOCKET] <path>
 139
 140     List QOM properties at a given path
 141
 142     positional arguments:
 143       <path>                QOM path
 144
 145     optional arguments:
 146       -h, --help            show this help message and exit
 147       --socket SOCKET, -s SOCKET
 148                             QMP socket path or address (addr:port). May also be
 149                             set via QMP_SOCKET environment variable.
 150     """
 151     name = 'list'
 152     help = 'List QOM properties at a given path'
 153
 154     @classmethod
 155     def configure_parser(cls, parser: argparse.ArgumentParser) -> None:
 156         super().configure_parser(parser)
 157         parser.add_argument(
 158             'path',
 159             metavar='<path>',
 160             action='store',
 161             help='QOM path',
 162         )
 163
 164     def __init__(self, args: argparse.Namespace):
 165         super().__init__(args)
 166         self.path = args.path
 167
 168     def run(self) -> int:
 169         rsp = self.qom_list(self.path)
 170         for item in rsp:
 171             if item.child:
 172                 print(f"{item.name}/")
 173             elif item.link:
 174                 print(f"@{item.name}/")
 175             else:
 176                 print(item.name)
 177         return 0
 178
 179
 180 class QOMTree(QOMCommand):
 181     """
 182     QOM Command - Show the full tree below a given path.
 183
 184     usage: qom-tree [-h] [--socket SOCKET] [<path>]
 185
 186     Show QOM tree from a given path
 187
 188     positional arguments:
 189       <path>                QOM path
 190
 191     optional arguments:
 192       -h, --help            show this help message and exit
 193       --socket SOCKET, -s SOCKET
 194                             QMP socket path or address (addr:port). May also be
 195                             set via QMP_SOCKET environment variable.
 196     """
 197     name = 'tree'
 198     help = 'Show QOM tree from a given path'
 199
 200     @classmethod
 201     def configure_parser(cls, parser: argparse.ArgumentParser) -> None:
 202         super().configure_parser(parser)
 203         parser.add_argument(
 204             'path',
 205             metavar='<path>',
 206             action='store',
 207             help='QOM path',
 208             nargs='?',
 209             default='/'
 210         )
 211
 212     def __init__(self, args: argparse.Namespace):
 213         super().__init__(args)
 214         self.path = args.path
 215
 216     def _list_node(self, path: str) -> None:
 217         print(path)
 218         items = self.qom_list(path)
 219         for item in items:
 220             if item.child:
 221                 continue
 222             try:
 223                 rsp = self.qmp.command('qom-get', path=path,
 224                                        property=item.name)
 225                 print(f"  {item.name}: {rsp} ({item.type})")
 226             except QMPResponseError as err:
 227                 print(f"  {item.name}: <EXCEPTION: {err!s}> ({item.type})")
 228         print('')
 229         for item in items:
 230             if not item.child:
 231                 continue
 232             if path == '/':
 233                 path = ''
 234             self._list_node(f"{path}/{item.name}")
 235
 236     def run(self) -> int:
 237         self._list_node(self.path)
 238         return 0
 239
 240
 241 def main() -> int:
 242     """QOM script main entry point."""
 243     parser = argparse.ArgumentParser(
 244         description='Query and manipulate QOM data'
 245     )
 246     subparsers = parser.add_subparsers(
 247         title='QOM commands',
 248         dest='command'
 249     )
 250
 251     for command in QOMCommand.__subclasses__():
 252         command.register(subparsers)
 253
 254     args = parser.parse_args()
 255
 256     if args.command is None:
 257         parser.error('Command not specified.')
 258         return 1
 259
 260     cmd_class = args.cmd_class
 261     assert isinstance(cmd_class, type(QOMCommand))
 262     return cmd_class.command_runner(args)