Instead we provide a meta class that can be used to customize the subclass creation. It's similar to '__init_subclass__' (see https://www.python.org/dev/peps/pep-0487/). Signed-off-by: Marc Hartmayer <mhartmay@xxxxxxxxxxxxx> Reviewed-by: Boris Fiuczynski <fiuczy@xxxxxxxxxxxxx> --- virtinst/cli.py | 921 +++++++++++++++++++++++++++--------------------- 1 file changed, 520 insertions(+), 401 deletions(-) diff --git a/virtinst/cli.py b/virtinst/cli.py index 105399a65e5c..ed8cbb6a0caa 100644 --- a/virtinst/cli.py +++ b/virtinst/cli.py @@ -17,6 +17,7 @@ import shlex import subprocess import sys import traceback +import types import libvirt @@ -1042,7 +1043,27 @@ def _parse_optstr_to_dict(optstr, virtargs, remove_first): return optdict -class VirtCLIParser(object): +class InitClass(type): + """Metaclass for providing the __init_class__ function. + + This allows the customisation of class creation. Similar to + '__init_subclass__' (see https://www.python.org/dev/peps/pep-0487/). + + """ + def __new__(cls, *args, **kwargs): + if len(args) != 3: + return super().__new__(cls, *args) + name, bases, ns = args + init = ns.get('__init_class__') + if isinstance(init, types.FunctionType): + # In case '__init_class__' isn't decorated with @classmethod + ns['__init_class__'] = classmethod(init) + self = super().__new__(cls, name, bases, ns) + self.__init_class__(**kwargs) + return self + + +class VirtCLIParser(metaclass=InitClass): """ Parse a compound arg string like --option foo=bar,baz=12. This is the desired interface to VirtCLIArgument and VirtCLIOptionString. @@ -1120,6 +1141,9 @@ class VirtCLIParser(object): def register(cls): _register_virt_parser(cls) + @classmethod + def __init_class__(cls, **kwargs): + """This method just terminates the super() chain""" def __init__(self, guest, optstr): self.guest = guest @@ -1312,20 +1336,22 @@ def convert_old_force(options): class ParseCLICheck(VirtCLIParser): cli_arg_name = "check" + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg(None, "path_in_use", is_onoff=True, + cb=cls.set_cb) + cls.add_arg(None, "disk_size", is_onoff=True, + cb=cls.set_cb) + cls.add_arg(None, "path_exists", is_onoff=True, + cb=cls.set_cb) + cls.add_arg("all_checks", "all", is_onoff=True) + def set_cb(self, inst, val, virtarg): # This sets properties on the _GlobalState objects inst.set_validation_check(virtarg.cliname, val) -ParseCLICheck.add_arg(None, "path_in_use", is_onoff=True, - cb=ParseCLICheck.set_cb) -ParseCLICheck.add_arg(None, "disk_size", is_onoff=True, - cb=ParseCLICheck.set_cb) -ParseCLICheck.add_arg(None, "path_exists", is_onoff=True, - cb=ParseCLICheck.set_cb) -ParseCLICheck.add_arg("all_checks", "all", is_onoff=True) - - def parse_check(checks): # Overwrite this for each parse for checkstr in util.listify(checks): @@ -1340,20 +1366,22 @@ def parse_check(checks): class ParserMetadata(VirtCLIParser): cli_arg_name = "metadata" + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg("name", "name", can_comma=True) + cls.add_arg("title", "title", can_comma=True) + cls.add_arg("uuid", "uuid") + cls.add_arg("description", "description", can_comma=True) + cls.add_arg(None, "os_name", cb=cls.set_os_name_cb) + cls.add_arg(None, "os_full_id", cb=cls.set_os_full_id_cb) + def set_os_name_cb(self, inst, val, virtarg): inst.set_os_name(val) def set_os_full_id_cb(self, inst, val, virtarg): inst.set_os_full_id(val) -ParserMetadata.add_arg("name", "name", can_comma=True) -ParserMetadata.add_arg("title", "title", can_comma=True) -ParserMetadata.add_arg("uuid", "uuid") -ParserMetadata.add_arg("description", "description", can_comma=True) -ParserMetadata.add_arg(None, "os_name", cb=ParserMetadata.set_os_name_cb) -ParserMetadata.add_arg(None, "os_full_id", cb=ParserMetadata.set_os_full_id_cb) - - #################### # --events parsing # #################### @@ -1361,11 +1389,13 @@ ParserMetadata.add_arg(None, "os_full_id", cb=ParserMetadata.set_os_full_id_cb) class ParserEvents(VirtCLIParser): cli_arg_name = "events" -ParserEvents.add_arg("on_poweroff", "on_poweroff") -ParserEvents.add_arg("on_reboot", "on_reboot") -ParserEvents.add_arg("on_crash", "on_crash") -ParserEvents.add_arg("on_lockfailure", "on_lockfailure") - + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg("on_poweroff", "on_poweroff") + cls.add_arg("on_reboot", "on_reboot") + cls.add_arg("on_crash", "on_crash") + cls.add_arg("on_lockfailure", "on_lockfailure") ###################### # --resource parsing # @@ -1376,7 +1406,10 @@ class ParserResource(VirtCLIParser): propname = "resource" remove_first = "partition" -ParserResource.add_arg("partition", "partition") + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg("partition", "partition") ###################### @@ -1388,9 +1421,11 @@ class ParserNumatune(VirtCLIParser): propname = "numatune" remove_first = "nodeset" -ParserNumatune.add_arg("memory_nodeset", "nodeset", can_comma=True) -ParserNumatune.add_arg("memory_mode", "mode") - + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg("memory_nodeset", "nodeset", can_comma=True) + cls.add_arg("memory_mode", "mode") #################### # --memory parsing # @@ -1403,13 +1438,15 @@ class ParserMemory(VirtCLIParser): def set_memory_cb(self, inst, val, virtarg): setattr(inst, virtarg.cliname, int(val) * 1024) - -ParserMemory.add_arg("memory", "memory", cb=ParserMemory.set_memory_cb) -ParserMemory.add_arg("maxmemory", "maxmemory", cb=ParserMemory.set_memory_cb) -ParserMemory.add_arg("memoryBacking.hugepages", "hugepages", is_onoff=True) -ParserMemory.add_arg("hotplugmemorymax", "hotplugmemorymax", - cb=ParserMemory.set_memory_cb) -ParserMemory.add_arg("hotplugmemoryslots", "hotplugmemoryslots") + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg("memory", "memory", cb=cls.set_memory_cb) + cls.add_arg("maxmemory", "maxmemory", cb=cls.set_memory_cb) + cls.add_arg("memoryBacking.hugepages", "hugepages", is_onoff=True) + cls.add_arg("hotplugmemorymax", "hotplugmemorymax", + cb=cls.set_memory_cb) + cls.add_arg("hotplugmemoryslots", "hotplugmemoryslots") ##################### @@ -1421,10 +1458,13 @@ class ParserMemtune(VirtCLIParser): propname = "memtune" remove_first = "soft_limit" -ParserMemtune.add_arg("hard_limit", "hard_limit") -ParserMemtune.add_arg("soft_limit", "soft_limit") -ParserMemtune.add_arg("swap_hard_limit", "swap_hard_limit") -ParserMemtune.add_arg("min_guarantee", "min_guarantee") + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg("hard_limit", "hard_limit") + cls.add_arg("soft_limit", "soft_limit") + cls.add_arg("swap_hard_limit", "swap_hard_limit") + cls.add_arg("min_guarantee", "min_guarantee") ####################### @@ -1436,9 +1476,12 @@ class ParserBlkiotune(VirtCLIParser): propname = "blkiotune" remove_first = "weight" -ParserBlkiotune.add_arg("weight", "weight") -ParserBlkiotune.add_arg("device_path", "device_path") -ParserBlkiotune.add_arg("device_weight", "device_weight") + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg("weight", "weight") + cls.add_arg("device_path", "device_path") + cls.add_arg("device_weight", "device_weight") ########################### @@ -1449,14 +1492,17 @@ class ParserMemoryBacking(VirtCLIParser): cli_arg_name = "memorybacking" propname = "memoryBacking" -ParserMemoryBacking.add_arg("hugepages", "hugepages", is_onoff=True) -ParserMemoryBacking.add_arg("page_size", "size") -ParserMemoryBacking.add_arg("page_unit", "unit") -ParserMemoryBacking.add_arg("page_nodeset", "nodeset", can_comma=True) -ParserMemoryBacking.add_arg("nosharepages", "nosharepages", is_onoff=True) -ParserMemoryBacking.add_arg("locked", "locked", is_onoff=True) -ParserMemoryBacking.add_arg("access_mode", "access_mode") -ParserMemoryBacking.add_arg("source_type", "source_type") + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg("hugepages", "hugepages", is_onoff=True) + cls.add_arg("page_size", "size") + cls.add_arg("page_unit", "unit") + cls.add_arg("page_nodeset", "nodeset", can_comma=True) + cls.add_arg("nosharepages", "nosharepages", is_onoff=True) + cls.add_arg("locked", "locked", is_onoff=True) + cls.add_arg("access_mode", "access_mode") + cls.add_arg("source_type", "source_type") ################# @@ -1469,7 +1515,6 @@ class ParserCPU(VirtCLIParser): remove_first = "model" stub_none = False - def cell_find_inst_cb(self, *args, **kwargs): cliarg = "cell" # cell[0-9]* objpropname = "cells" # cpu.cells @@ -1543,33 +1588,35 @@ class ParserCPU(VirtCLIParser): return super()._parse(inst) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg(None, "model", cb=cls.set_model_cb) + cls.add_arg("mode", "mode") + cls.add_arg("match", "match") + cls.add_arg("vendor", "vendor") -ParserCPU.add_arg(None, "model", cb=ParserCPU.set_model_cb) -ParserCPU.add_arg("mode", "mode") -ParserCPU.add_arg("match", "match") -ParserCPU.add_arg("vendor", "vendor") + cls.add_arg(None, "force", is_list=True, cb=cls.set_feature_cb) + cls.add_arg(None, "require", is_list=True, cb=cls.set_feature_cb) + cls.add_arg(None, "optional", is_list=True, cb=cls.set_feature_cb) + cls.add_arg(None, "disable", is_list=True, cb=cls.set_feature_cb) + cls.add_arg(None, "forbid", is_list=True, cb=cls.set_feature_cb) -ParserCPU.add_arg(None, "force", is_list=True, cb=ParserCPU.set_feature_cb) -ParserCPU.add_arg(None, "require", is_list=True, cb=ParserCPU.set_feature_cb) -ParserCPU.add_arg(None, "optional", is_list=True, cb=ParserCPU.set_feature_cb) -ParserCPU.add_arg(None, "disable", is_list=True, cb=ParserCPU.set_feature_cb) -ParserCPU.add_arg(None, "forbid", is_list=True, cb=ParserCPU.set_feature_cb) + # Options for CPU.cells config + cls.add_arg("id", "cell[0-9]*.id", + find_inst_cb=cls.cell_find_inst_cb) + cls.add_arg("cpus", "cell[0-9]*.cpus", can_comma=True, + find_inst_cb=cls.cell_find_inst_cb) + cls.add_arg("memory", "cell[0-9]*.memory", + find_inst_cb=cls.cell_find_inst_cb) + cls.add_arg("id", "cell[0-9]*.distances.sibling[0-9]*.id", + find_inst_cb=cls.sibling_find_inst_cb) + cls.add_arg("value", "cell[0-9]*.distances.sibling[0-9]*.value", + find_inst_cb=cls.sibling_find_inst_cb) -# Options for CPU.cells config -ParserCPU.add_arg("id", "cell[0-9]*.id", - find_inst_cb=ParserCPU.cell_find_inst_cb) -ParserCPU.add_arg("cpus", "cell[0-9]*.cpus", can_comma=True, - find_inst_cb=ParserCPU.cell_find_inst_cb) -ParserCPU.add_arg("memory", "cell[0-9]*.memory", - find_inst_cb=ParserCPU.cell_find_inst_cb) -ParserCPU.add_arg("id", "cell[0-9]*.distances.sibling[0-9]*.id", - find_inst_cb=ParserCPU.sibling_find_inst_cb) -ParserCPU.add_arg("value", "cell[0-9]*.distances.sibling[0-9]*.value", - find_inst_cb=ParserCPU.sibling_find_inst_cb) - -# Options for CPU.cache -ParserCPU.add_arg("mode", "cache.mode", find_inst_cb=ParserCPU.set_l3_cache_cb) -ParserCPU.add_arg("level", "cache.level", find_inst_cb=ParserCPU.set_l3_cache_cb) + # Options for CPU.cache + cls.add_arg("mode", "cache.mode", find_inst_cb=cls.set_l3_cache_cb) + cls.add_arg("level", "cache.level", find_inst_cb=cls.set_l3_cache_cb) ##################### @@ -1588,11 +1635,14 @@ class ParserCputune(VirtCLIParser): cb = self._make_find_inst_cb(cliarg, objpropname) return cb(*args, **kwargs) -# Options for CPU.vcpus config -ParserCputune.add_arg("vcpu", "vcpupin[0-9]*.vcpu", - find_inst_cb=ParserCputune.vcpu_find_inst_cb) -ParserCputune.add_arg("cpuset", "vcpupin[0-9]*.cpuset", can_comma=True, - find_inst_cb=ParserCputune.vcpu_find_inst_cb) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + # Options for CPU.vcpus config + cls.add_arg("vcpu", "vcpupin[0-9]*.vcpu", + find_inst_cb=cls.vcpu_find_inst_cb) + cls.add_arg("cpuset", "vcpupin[0-9]*.cpuset", can_comma=True, + find_inst_cb=cls.vcpu_find_inst_cb) ################### @@ -1631,16 +1681,18 @@ class ParserVCPU(VirtCLIParser): inst.vcpus = inst.cpu.vcpus_from_topology() return ret + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg("cpu.sockets", "sockets") + cls.add_arg("cpu.cores", "cores") + cls.add_arg("cpu.threads", "threads") -ParserVCPU.add_arg("cpu.sockets", "sockets") -ParserVCPU.add_arg("cpu.cores", "cores") -ParserVCPU.add_arg("cpu.threads", "threads") + cls.add_arg(None, "vcpus", cb=cls.set_vcpus_cb) + cls.add_arg("vcpus", "maxvcpus") -ParserVCPU.add_arg(None, "vcpus", cb=ParserVCPU.set_vcpus_cb) -ParserVCPU.add_arg("vcpus", "maxvcpus") - -ParserVCPU.add_arg(None, "cpuset", can_comma=True, cb=ParserVCPU.set_cpuset_cb) -ParserVCPU.add_arg("vcpu_placement", "placement") + cls.add_arg(None, "cpuset", can_comma=True, cb=cls.set_cpuset_cb) + cls.add_arg("vcpu_placement", "placement") ################## @@ -1689,38 +1741,40 @@ class ParserBoot(VirtCLIParser): super()._parse(inst) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + # UEFI depends on these bits, so set them first + cls.add_arg("arch", "arch") + cls.add_arg(None, "bootloader", cb=cls.set_bootloader_cb) + cls.add_arg(None, "domain_type", cb=cls.set_domain_type_cb) + cls.add_arg("os_type", "os_type") + cls.add_arg(None, "emulator", cb=cls.set_emulator_cb) + cls.add_arg("machine", "machine") + cls.add_arg(None, "uefi", cb=cls.set_uefi_cb, is_novalue=True) -# UEFI depends on these bits, so set them first -ParserBoot.add_arg("arch", "arch") -ParserBoot.add_arg(None, "bootloader", cb=ParserBoot.set_bootloader_cb) -ParserBoot.add_arg(None, "domain_type", cb=ParserBoot.set_domain_type_cb) -ParserBoot.add_arg("os_type", "os_type") -ParserBoot.add_arg(None, "emulator", cb=ParserBoot.set_emulator_cb) -ParserBoot.add_arg("machine", "machine") -ParserBoot.add_arg(None, "uefi", cb=ParserBoot.set_uefi_cb, is_novalue=True) + cls.add_arg("useserial", "useserial", is_onoff=True) + cls.add_arg("enable_bootmenu", "menu", is_onoff=True) + cls.add_arg("rebootTimeout", "rebootTimeout") + cls.add_arg("kernel", "kernel") + cls.add_arg("initrd", "initrd") + cls.add_arg("dtb", "dtb") + cls.add_arg("loader", "loader") + cls.add_arg("loader_ro", "loader_ro", is_onoff=True) + cls.add_arg("loader_type", "loader_type") + cls.add_arg("loader_secure", "loader_secure", is_onoff=True) + cls.add_arg("nvram", "nvram") + cls.add_arg("nvram_template", "nvram_template") + cls.add_arg("kernel_args", "kernel_args", + aliases=["extra_args"], can_comma=True) + cls.add_arg("init", "init") + cls.add_arg("initargs", "initargs", cb=cls.set_initargs_cb) + cls.add_arg("smbios_mode", "smbios_mode") -ParserBoot.add_arg("useserial", "useserial", is_onoff=True) -ParserBoot.add_arg("enable_bootmenu", "menu", is_onoff=True) -ParserBoot.add_arg("rebootTimeout", "rebootTimeout") -ParserBoot.add_arg("kernel", "kernel") -ParserBoot.add_arg("initrd", "initrd") -ParserBoot.add_arg("dtb", "dtb") -ParserBoot.add_arg("loader", "loader") -ParserBoot.add_arg("loader_ro", "loader_ro", is_onoff=True) -ParserBoot.add_arg("loader_type", "loader_type") -ParserBoot.add_arg("loader_secure", "loader_secure", is_onoff=True) -ParserBoot.add_arg("nvram", "nvram") -ParserBoot.add_arg("nvram_template", "nvram_template") -ParserBoot.add_arg("kernel_args", "kernel_args", - aliases=["extra_args"], can_comma=True) -ParserBoot.add_arg("init", "init") -ParserBoot.add_arg("initargs", "initargs", cb=ParserBoot.set_initargs_cb) -ParserBoot.add_arg("smbios_mode", "smbios_mode") - -# This is simply so the boot options are advertised with --boot help, -# actual processing is handled by _parse -for _bootdev in DomainOs.BOOT_DEVICES: - ParserBoot.add_arg(None, _bootdev, is_novalue=True, cb=ParserBoot.noset_cb) + # This is simply so the boot options are advertised with --boot help, + # actual processing is handled by _parse + for _bootdev in DomainOs.BOOT_DEVICES: + cls.add_arg(None, _bootdev, is_novalue=True, cb=cls.noset_cb) ################### @@ -1731,12 +1785,15 @@ class ParserIdmap(VirtCLIParser): cli_arg_name = "idmap" propname = "idmap" -ParserIdmap.add_arg("uid_start", "uid_start") -ParserIdmap.add_arg("uid_target", "uid_target") -ParserIdmap.add_arg("uid_count", "uid_count") -ParserIdmap.add_arg("gid_start", "gid_start") -ParserIdmap.add_arg("gid_target", "gid_target") -ParserIdmap.add_arg("gid_count", "gid_count") + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg("uid_start", "uid_start") + cls.add_arg("uid_target", "uid_target") + cls.add_arg("uid_count", "uid_count") + cls.add_arg("gid_start", "gid_start") + cls.add_arg("gid_target", "gid_target") + cls.add_arg("gid_count", "gid_count") ###################### @@ -1747,11 +1804,14 @@ class ParserSecurity(VirtCLIParser): cli_arg_name = "security" propname = "seclabels" -ParserSecurity.add_arg("type", "type") -ParserSecurity.add_arg("model", "model") -ParserSecurity.add_arg("relabel", "relabel", is_onoff=True) -ParserSecurity.add_arg("label", "label", can_comma=True) -ParserSecurity.add_arg("baselabel", "label", can_comma=True) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg("type", "type") + cls.add_arg("model", "model") + cls.add_arg("relabel", "relabel", is_onoff=True) + cls.add_arg("label", "label", can_comma=True) + cls.add_arg("baselabel", "label", can_comma=True) ###################### @@ -1762,31 +1822,34 @@ class ParserFeatures(VirtCLIParser): cli_arg_name = "features" propname = "features" -ParserFeatures.add_arg("acpi", "acpi", is_onoff=True) -ParserFeatures.add_arg("apic", "apic", is_onoff=True) -ParserFeatures.add_arg("pae", "pae", is_onoff=True) -ParserFeatures.add_arg("privnet", "privnet", is_onoff=True) -ParserFeatures.add_arg("hap", "hap", is_onoff=True) -ParserFeatures.add_arg("viridian", "viridian", is_onoff=True) -ParserFeatures.add_arg("eoi", "eoi", is_onoff=True) -ParserFeatures.add_arg("pmu", "pmu", is_onoff=True) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg("acpi", "acpi", is_onoff=True) + cls.add_arg("apic", "apic", is_onoff=True) + cls.add_arg("pae", "pae", is_onoff=True) + cls.add_arg("privnet", "privnet", is_onoff=True) + cls.add_arg("hap", "hap", is_onoff=True) + cls.add_arg("viridian", "viridian", is_onoff=True) + cls.add_arg("eoi", "eoi", is_onoff=True) + cls.add_arg("pmu", "pmu", is_onoff=True) -ParserFeatures.add_arg("hyperv_reset", "hyperv_reset", is_onoff=True) -ParserFeatures.add_arg("hyperv_vapic", "hyperv_vapic", is_onoff=True) -ParserFeatures.add_arg("hyperv_relaxed", "hyperv_relaxed", is_onoff=True) -ParserFeatures.add_arg("hyperv_spinlocks", "hyperv_spinlocks", is_onoff=True) -ParserFeatures.add_arg("hyperv_spinlocks_retries", - "hyperv_spinlocks_retries") -ParserFeatures.add_arg("hyperv_synic", "hyperv_synic", is_onoff=True) + cls.add_arg("hyperv_reset", "hyperv_reset", is_onoff=True) + cls.add_arg("hyperv_vapic", "hyperv_vapic", is_onoff=True) + cls.add_arg("hyperv_relaxed", "hyperv_relaxed", is_onoff=True) + cls.add_arg("hyperv_spinlocks", "hyperv_spinlocks", is_onoff=True) + cls.add_arg("hyperv_spinlocks_retries", + "hyperv_spinlocks_retries") + cls.add_arg("hyperv_synic", "hyperv_synic", is_onoff=True) -ParserFeatures.add_arg("vmport", "vmport", is_onoff=True) -ParserFeatures.add_arg("kvm_hidden", "kvm_hidden", is_onoff=True) -ParserFeatures.add_arg("pvspinlock", "pvspinlock", is_onoff=True) + cls.add_arg("vmport", "vmport", is_onoff=True) + cls.add_arg("kvm_hidden", "kvm_hidden", is_onoff=True) + cls.add_arg("pvspinlock", "pvspinlock", is_onoff=True) -ParserFeatures.add_arg("gic_version", "gic_version") + cls.add_arg("gic_version", "gic_version") -ParserFeatures.add_arg("smm", "smm", is_onoff=True) -ParserFeatures.add_arg("vmcoreinfo", "vmcoreinfo", is_onoff=True) + cls.add_arg("smm", "smm", is_onoff=True) + cls.add_arg("vmcoreinfo", "vmcoreinfo", is_onoff=True) ################### @@ -1812,14 +1875,16 @@ class ParserClock(VirtCLIParser): setattr(timerobj, attrname, val) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg("offset", "offset") -ParserClock.add_arg("offset", "offset") - -for _tname in DomainClock.TIMER_NAMES: - ParserClock.add_arg(None, _tname + "_present", + for _tname in DomainClock.TIMER_NAMES: + cls.add_arg(None, _tname + "_present", is_onoff=True, - cb=ParserClock.set_timer) - ParserClock.add_arg(None, _tname + "_tickpolicy", cb=ParserClock.set_timer) + cb=cls.set_timer) + cls.add_arg(None, _tname + "_tickpolicy", cb=cls.set_timer) ################ @@ -1830,8 +1895,11 @@ class ParserPM(VirtCLIParser): cli_arg_name = "pm" propname = "pm" -ParserPM.add_arg("suspend_to_mem", "suspend_to_mem", is_onoff=True) -ParserPM.add_arg("suspend_to_disk", "suspend_to_disk", is_onoff=True) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg("suspend_to_mem", "suspend_to_mem", is_onoff=True) + cls.add_arg("suspend_to_disk", "suspend_to_disk", is_onoff=True) ##################### @@ -1870,33 +1938,36 @@ class ParserSysinfo(VirtCLIParser): return super()._parse(inst) -# <sysinfo type='smbios'> -ParserSysinfo.add_arg("type", "type", - cb=ParserSysinfo.set_type_cb, can_comma=True) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + # <sysinfo type='smbios'> + cls.add_arg("type", "type", + cb=cls.set_type_cb, can_comma=True) -# <bios> type 0 BIOS Information -ParserSysinfo.add_arg("bios_vendor", "bios_vendor") -ParserSysinfo.add_arg("bios_version", "bios_version") -ParserSysinfo.add_arg("bios_date", "bios_date") -ParserSysinfo.add_arg("bios_release", "bios_release") + # <bios> type 0 BIOS Information + cls.add_arg("bios_vendor", "bios_vendor") + cls.add_arg("bios_version", "bios_version") + cls.add_arg("bios_date", "bios_date") + cls.add_arg("bios_release", "bios_release") -# <system> type 1 System Information -ParserSysinfo.add_arg("system_manufacturer", "system_manufacturer") -ParserSysinfo.add_arg("system_product", "system_product") -ParserSysinfo.add_arg("system_version", "system_version") -ParserSysinfo.add_arg("system_serial", "system_serial") -ParserSysinfo.add_arg("system_uuid", "system_uuid", - cb=ParserSysinfo.set_uuid_cb) -ParserSysinfo.add_arg("system_sku", "system_sku") -ParserSysinfo.add_arg("system_family", "system_family") + # <system> type 1 System Information + cls.add_arg("system_manufacturer", "system_manufacturer") + cls.add_arg("system_product", "system_product") + cls.add_arg("system_version", "system_version") + cls.add_arg("system_serial", "system_serial") + cls.add_arg("system_uuid", "system_uuid", + cb=cls.set_uuid_cb) + cls.add_arg("system_sku", "system_sku") + cls.add_arg("system_family", "system_family") -# <baseBoard> type 2 Baseboard (or Module) Information -ParserSysinfo.add_arg("baseBoard_manufacturer", "baseBoard_manufacturer") -ParserSysinfo.add_arg("baseBoard_product", "baseBoard_product") -ParserSysinfo.add_arg("baseBoard_version", "baseBoard_version") -ParserSysinfo.add_arg("baseBoard_serial", "baseBoard_serial") -ParserSysinfo.add_arg("baseBoard_asset", "baseBoard_asset") -ParserSysinfo.add_arg("baseBoard_location", "baseBoard_location") + # <baseBoard> type 2 Baseboard (or Module) Information + cls.add_arg("baseBoard_manufacturer", "baseBoard_manufacturer") + cls.add_arg("baseBoard_product", "baseBoard_product") + cls.add_arg("baseBoard_version", "baseBoard_version") + cls.add_arg("baseBoard_serial", "baseBoard_serial") + cls.add_arg("baseBoard_asset", "baseBoard_asset") + cls.add_arg("baseBoard_location", "baseBoard_location") ############################## @@ -1930,9 +2001,11 @@ class ParserQemuCLI(VirtCLIParser): self.optdict["args"] = self.optstr return super()._parse(inst) - -ParserQemuCLI.add_arg(None, "args", cb=ParserQemuCLI.args_cb, can_comma=True) -ParserQemuCLI.add_arg(None, "env", cb=ParserQemuCLI.env_cb, can_comma=True) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg(None, "args", cb=cls.args_cb, can_comma=True) + cls.add_arg(None, "env", cb=cls.env_cb, can_comma=True) ########################## @@ -2096,74 +2169,74 @@ class ParserDisk(VirtCLIParser): return inst + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + _add_device_address_args(cls) + # These are all handled specially in _parse + cls.add_arg(None, "backing_store", cb=cls.noset_cb) + cls.add_arg(None, "backing_format", cb=cls.noset_cb) + cls.add_arg(None, "pool", cb=cls.noset_cb) + cls.add_arg(None, "vol", cb=cls.noset_cb) + cls.add_arg(None, "size", cb=cls.noset_cb) + cls.add_arg(None, "format", cb=cls.noset_cb) + cls.add_arg(None, "sparse", cb=cls.noset_cb) + cls.add_arg("source_pool", "source_pool") + cls.add_arg("source_volume", "source_volume") + cls.add_arg("source_name", "source_name") + cls.add_arg("source_protocol", "source_protocol") + cls.add_arg("source_host_name", "source_host_name") + cls.add_arg("source_host_port", "source_host_port") + cls.add_arg("source_host_socket", "source_host_socket") + cls.add_arg("source_host_transport", "source_host_transport") -_add_device_address_args(ParserDisk) + cls.add_arg("path", "path") + cls.add_arg("device", "device") + cls.add_arg("snapshot_policy", "snapshot_policy") + cls.add_arg("bus", "bus") + cls.add_arg("removable", "removable", is_onoff=True) + cls.add_arg("driver_cache", "cache") + cls.add_arg("driver_discard", "discard") + cls.add_arg("driver_detect_zeroes", "detect_zeroes") + cls.add_arg("driver_name", "driver_name") + cls.add_arg("driver_type", "driver_type") + cls.add_arg("driver_copy_on_read", "driver.copy_on_read", is_onoff=True) + cls.add_arg("driver_io", "io") + cls.add_arg("error_policy", "error_policy") + cls.add_arg("serial", "serial") + cls.add_arg("target", "target") + cls.add_arg("startup_policy", "startup_policy") + cls.add_arg("read_only", "readonly", is_onoff=True) + cls.add_arg("shareable", "shareable", is_onoff=True) + cls.add_arg("boot.order", "boot_order") -# These are all handled specially in _parse -ParserDisk.add_arg(None, "backing_store", cb=ParserDisk.noset_cb) -ParserDisk.add_arg(None, "backing_format", cb=ParserDisk.noset_cb) -ParserDisk.add_arg(None, "pool", cb=ParserDisk.noset_cb) -ParserDisk.add_arg(None, "vol", cb=ParserDisk.noset_cb) -ParserDisk.add_arg(None, "size", cb=ParserDisk.noset_cb) -ParserDisk.add_arg(None, "format", cb=ParserDisk.noset_cb) -ParserDisk.add_arg(None, "sparse", cb=ParserDisk.noset_cb) + cls.add_arg("iotune_rbs", "read_bytes_sec") + cls.add_arg("iotune_wbs", "write_bytes_sec") + cls.add_arg("iotune_tbs", "total_bytes_sec") + cls.add_arg("iotune_ris", "read_iops_sec") + cls.add_arg("iotune_wis", "write_iops_sec") + cls.add_arg("iotune_tis", "total_iops_sec") + cls.add_arg("sgio", "sgio") + cls.add_arg("logical_block_size", "logical_block_size") + cls.add_arg("physical_block_size", "physical_block_size") -ParserDisk.add_arg("source_pool", "source_pool") -ParserDisk.add_arg("source_volume", "source_volume") -ParserDisk.add_arg("source_name", "source_name") -ParserDisk.add_arg("source_protocol", "source_protocol") -ParserDisk.add_arg("source_host_name", "source_host_name") -ParserDisk.add_arg("source_host_port", "source_host_port") -ParserDisk.add_arg("source_host_socket", "source_host_socket") -ParserDisk.add_arg("source_host_transport", "source_host_transport") + # DeviceDisk.seclabels properties + cls.add_arg("model", "seclabel[0-9]*.model", + find_inst_cb=cls.seclabel_find_inst_cb) + cls.add_arg("relabel", "seclabel[0-9]*.relabel", is_onoff=True, + find_inst_cb=cls.seclabel_find_inst_cb) + cls.add_arg("label", "seclabel[0-9]*.label", can_comma=True, + find_inst_cb=cls.seclabel_find_inst_cb) -ParserDisk.add_arg("path", "path") -ParserDisk.add_arg("device", "device") -ParserDisk.add_arg("snapshot_policy", "snapshot_policy") -ParserDisk.add_arg("bus", "bus") -ParserDisk.add_arg("removable", "removable", is_onoff=True) -ParserDisk.add_arg("driver_cache", "cache") -ParserDisk.add_arg("driver_discard", "discard") -ParserDisk.add_arg("driver_detect_zeroes", "detect_zeroes") -ParserDisk.add_arg("driver_name", "driver_name") -ParserDisk.add_arg("driver_type", "driver_type") -ParserDisk.add_arg("driver_copy_on_read", "driver.copy_on_read", is_onoff=True) -ParserDisk.add_arg("driver_io", "io") -ParserDisk.add_arg("error_policy", "error_policy") -ParserDisk.add_arg("serial", "serial") -ParserDisk.add_arg("target", "target") -ParserDisk.add_arg("startup_policy", "startup_policy") -ParserDisk.add_arg("read_only", "readonly", is_onoff=True) -ParserDisk.add_arg("shareable", "shareable", is_onoff=True) -ParserDisk.add_arg("boot.order", "boot_order") + cls.add_arg("geometry_cyls", "geometry.cyls") + cls.add_arg("geometry_heads", "geometry.heads") + cls.add_arg("geometry_secs", "geometry.secs") + cls.add_arg("geometry_trans", "geometry.trans") -ParserDisk.add_arg("iotune_rbs", "read_bytes_sec") -ParserDisk.add_arg("iotune_wbs", "write_bytes_sec") -ParserDisk.add_arg("iotune_tbs", "total_bytes_sec") -ParserDisk.add_arg("iotune_ris", "read_iops_sec") -ParserDisk.add_arg("iotune_wis", "write_iops_sec") -ParserDisk.add_arg("iotune_tis", "total_iops_sec") -ParserDisk.add_arg("sgio", "sgio") -ParserDisk.add_arg("logical_block_size", "logical_block_size") -ParserDisk.add_arg("physical_block_size", "physical_block_size") - -# DeviceDisk.seclabels properties -ParserDisk.add_arg("model", "seclabel[0-9]*.model", - find_inst_cb=ParserDisk.seclabel_find_inst_cb) -ParserDisk.add_arg("relabel", "seclabel[0-9]*.relabel", is_onoff=True, - find_inst_cb=ParserDisk.seclabel_find_inst_cb) -ParserDisk.add_arg("label", "seclabel[0-9]*.label", can_comma=True, - find_inst_cb=ParserDisk.seclabel_find_inst_cb) - -ParserDisk.add_arg("geometry_cyls", "geometry.cyls") -ParserDisk.add_arg("geometry_heads", "geometry.heads") -ParserDisk.add_arg("geometry_secs", "geometry.secs") -ParserDisk.add_arg("geometry_trans", "geometry.trans") - -ParserDisk.add_arg("reservations_managed", "reservations.managed") -ParserDisk.add_arg("reservations_source_type", "reservations.source.type") -ParserDisk.add_arg("reservations_source_path", "reservations.source.path") -ParserDisk.add_arg("reservations_source_mode", "reservations.source.mode") + cls.add_arg("reservations_managed", "reservations.managed") + cls.add_arg("reservations_source_type", "reservations.source.type") + cls.add_arg("reservations_source_path", "reservations.source.path") + cls.add_arg("reservations_source_mode", "reservations.source.mode") ##################### @@ -2215,43 +2288,45 @@ class ParserNetwork(VirtCLIParser): return super()._parse(inst) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + _add_device_address_args(cls) + cls.add_arg("type", "type", cb=cls.set_type_cb) + cls.add_arg("trustGuestRxFilters", "trustGuestRxFilters", + is_onoff=True) + cls.add_arg("source", "source") + cls.add_arg("source_mode", "source_mode") + cls.add_arg("source_type", "source_type") + cls.add_arg("source_path", "source_path") + cls.add_arg("portgroup", "portgroup") + cls.add_arg("target_dev", "target") + cls.add_arg("model", "model") + cls.add_arg("macaddr", "mac", cb=cls.set_mac_cb) + cls.add_arg("filterref", "filterref") + cls.add_arg("boot.order", "boot_order") + cls.add_arg("link_state", "link_state", + cb=cls.set_link_state) -_add_device_address_args(ParserNetwork) -ParserNetwork.add_arg("type", "type", cb=ParserNetwork.set_type_cb) -ParserNetwork.add_arg("trustGuestRxFilters", "trustGuestRxFilters", - is_onoff=True) -ParserNetwork.add_arg("source", "source") -ParserNetwork.add_arg("source_mode", "source_mode") -ParserNetwork.add_arg("source_type", "source_type") -ParserNetwork.add_arg("source_path", "source_path") -ParserNetwork.add_arg("portgroup", "portgroup") -ParserNetwork.add_arg("target_dev", "target") -ParserNetwork.add_arg("model", "model") -ParserNetwork.add_arg("macaddr", "mac", cb=ParserNetwork.set_mac_cb) -ParserNetwork.add_arg("filterref", "filterref") -ParserNetwork.add_arg("boot.order", "boot_order") -ParserNetwork.add_arg("link_state", "link_state", - cb=ParserNetwork.set_link_state) + cls.add_arg("driver_name", "driver_name") + cls.add_arg("driver_queues", "driver_queues") -ParserNetwork.add_arg("driver_name", "driver_name") -ParserNetwork.add_arg("driver_queues", "driver_queues") + cls.add_arg("rom_file", "rom_file") + cls.add_arg("rom_bar", "rom_bar", is_onoff=True) -ParserNetwork.add_arg("rom_file", "rom_file") -ParserNetwork.add_arg("rom_bar", "rom_bar", is_onoff=True) + cls.add_arg("mtu_size", "mtu.size") -ParserNetwork.add_arg("mtu_size", "mtu.size") - -# For 802.1Qbg -ParserNetwork.add_arg("virtualport.type", "virtualport_type") -ParserNetwork.add_arg("virtualport.managerid", "virtualport_managerid") -ParserNetwork.add_arg("virtualport.typeid", "virtualport_typeid") -ParserNetwork.add_arg("virtualport.typeidversion", - "virtualport_typeidversion") -ParserNetwork.add_arg("virtualport.instanceid", "virtualport_instanceid") -# For openvswitch & 802.1Qbh -ParserNetwork.add_arg("virtualport.profileid", "virtualport_profileid") -# For openvswitch & midonet -ParserNetwork.add_arg("virtualport.interfaceid", "virtualport_interfaceid") + # For 802.1Qbg + cls.add_arg("virtualport.type", "virtualport_type") + cls.add_arg("virtualport.managerid", "virtualport_managerid") + cls.add_arg("virtualport.typeid", "virtualport_typeid") + cls.add_arg("virtualport.typeidversion", + "virtualport_typeidversion") + cls.add_arg("virtualport.instanceid", "virtualport_instanceid") + # For openvswitch & 802.1Qbh + cls.add_arg("virtualport.profileid", "virtualport_profileid") + # For openvswitch & midonet + cls.add_arg("virtualport.interfaceid", "virtualport_interfaceid") ###################### @@ -2324,34 +2399,39 @@ class ParserGraphics(VirtCLIParser): return ret -_add_device_address_args(ParserGraphics) -ParserGraphics.add_arg(None, "type", cb=ParserGraphics.set_type_cb) -ParserGraphics.add_arg("port", "port") -ParserGraphics.add_arg("tlsPort", "tlsport") -ParserGraphics.add_arg("listen", "listen", cb=ParserGraphics.set_listen_cb) -ParserGraphics.add_arg("type", "listens[0-9]*.type", - find_inst_cb=ParserGraphics.listens_find_inst_cb) -ParserGraphics.add_arg("address", "listens[0-9]*.address", - find_inst_cb=ParserGraphics.listens_find_inst_cb) -ParserGraphics.add_arg("network", "listens[0-9]*.network", - find_inst_cb=ParserGraphics.listens_find_inst_cb) -ParserGraphics.add_arg("socket", "listens[0-9]*.socket", - find_inst_cb=ParserGraphics.listens_find_inst_cb) -ParserGraphics.add_arg(None, "keymap", cb=ParserGraphics.set_keymap_cb) -ParserGraphics.add_arg("passwd", "password") -ParserGraphics.add_arg("passwdValidTo", "passwordvalidto") -ParserGraphics.add_arg("connected", "connected") -ParserGraphics.add_arg("defaultMode", "defaultMode") + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + _add_device_address_args(cls) + cls.add_arg(None, "type", cb=cls.set_type_cb) + cls.add_arg("port", "port") + cls.add_arg("tlsPort", "tlsport") + cls.add_arg("listen", "listen", cb=cls.set_listen_cb) + cls.add_arg("type", "listens[0-9]*.type", + find_inst_cb=cls.listens_find_inst_cb) + cls.add_arg("address", "listens[0-9]*.address", + find_inst_cb=cls.listens_find_inst_cb) + cls.add_arg("network", "listens[0-9]*.network", + find_inst_cb=cls.listens_find_inst_cb) + cls.add_arg("socket", "listens[0-9]*.socket", + find_inst_cb=cls.listens_find_inst_cb) + cls.add_arg(None, "keymap", cb=cls.set_keymap_cb) + cls.add_arg("passwd", "password") + cls.add_arg("passwdValidTo", "passwordvalidto") + cls.add_arg("connected", "connected") + cls.add_arg("defaultMode", "defaultMode") + + cls.add_arg("image_compression", "image_compression") + cls.add_arg("streaming_mode", "streaming_mode") + cls.add_arg("clipboard_copypaste", "clipboard_copypaste", + is_onoff=True) + cls.add_arg("mouse_mode", "mouse_mode") + cls.add_arg("filetransfer_enable", "filetransfer_enable", + is_onoff=True) + cls.add_arg("gl", "gl", is_onoff=True) + cls.add_arg("rendernode", "rendernode") + -ParserGraphics.add_arg("image_compression", "image_compression") -ParserGraphics.add_arg("streaming_mode", "streaming_mode") -ParserGraphics.add_arg("clipboard_copypaste", "clipboard_copypaste", - is_onoff=True) -ParserGraphics.add_arg("mouse_mode", "mouse_mode") -ParserGraphics.add_arg("filetransfer_enable", "filetransfer_enable", - is_onoff=True) -ParserGraphics.add_arg("gl", "gl", is_onoff=True) -ParserGraphics.add_arg("rendernode", "rendernode") ######################## @@ -2373,14 +2453,16 @@ class ParserController(VirtCLIParser): return DeviceController.get_usb3_controller(inst.conn, self.guest) return super()._parse(inst) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + _add_device_address_args(cls) + cls.add_arg("type", "type") + cls.add_arg("model", "model") + cls.add_arg("index", "index") + cls.add_arg("master_startport", "master") -_add_device_address_args(ParserController) -ParserController.add_arg("type", "type") -ParserController.add_arg("model", "model") -ParserController.add_arg("index", "index") -ParserController.add_arg("master_startport", "master") - -ParserController.add_arg(None, "address", cb=ParserController.set_server_cb) + cls.add_arg(None, "address", cb=cls.set_server_cb) ################### @@ -2392,9 +2474,12 @@ class ParserInput(VirtCLIParser): propname = "devices.input" remove_first = "type" -_add_device_address_args(ParserInput) -ParserInput.add_arg("type", "type", ignore_default=True) -ParserInput.add_arg("bus", "bus", ignore_default=True) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + _add_device_address_args(cls) + cls.add_arg("type", "type", ignore_default=True) + cls.add_arg("bus", "bus", ignore_default=True) ####################### @@ -2406,9 +2491,12 @@ class ParserSmartcard(VirtCLIParser): propname = "devices.smartcard" remove_first = "mode" -_add_device_address_args(ParserSmartcard) -ParserSmartcard.add_arg("mode", "mode", ignore_default=True) -ParserSmartcard.add_arg("type", "type", ignore_default=True) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + _add_device_address_args(cls) + cls.add_arg("mode", "mode", ignore_default=True) + cls.add_arg("type", "type", ignore_default=True) ###################### @@ -2430,11 +2518,14 @@ class ParserRedir(VirtCLIParser): return return super()._parse(inst) -_add_device_address_args(ParserRedir) -ParserRedir.add_arg("bus", "bus", ignore_default=True) -ParserRedir.add_arg("type", "type", ignore_default=True) -ParserRedir.add_arg("boot.order", "boot_order") -ParserRedir.add_arg(None, "server", cb=ParserRedir.set_server_cb) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + _add_device_address_args(cls) + cls.add_arg("bus", "bus", ignore_default=True) + cls.add_arg("type", "type", ignore_default=True) + cls.add_arg("boot.order", "boot_order") + cls.add_arg(None, "server", cb=cls.set_server_cb) ################# @@ -2451,11 +2542,14 @@ class ParserTPM(VirtCLIParser): self.optdict["path"] = self.optdict.pop("type") return super()._parse(inst) -_add_device_address_args(ParserTPM) -ParserTPM.add_arg("type", "type") -ParserTPM.add_arg("model", "model") -ParserTPM.add_arg("version", "version") -ParserTPM.add_arg("device_path", "path") + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + _add_device_address_args(cls) + cls.add_arg("type", "type") + cls.add_arg("model", "model") + cls.add_arg("version", "version") + cls.add_arg("device_path", "path") ################# @@ -2508,22 +2602,24 @@ class ParserRNG(VirtCLIParser): return super()._parse(inst) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + _add_device_address_args(cls) + cls.add_arg("type", "type") -_add_device_address_args(ParserRNG) -ParserRNG.add_arg("type", "type") + cls.add_arg(None, "backend_mode", cb=cls.set_backend_cb) + cls.add_arg(None, "backend_type", cb=cls.set_backend_cb) -ParserRNG.add_arg(None, "backend_mode", cb=ParserRNG.set_backend_cb) -ParserRNG.add_arg(None, "backend_type", cb=ParserRNG.set_backend_cb) + cls.add_arg(None, "backend_host", cb=cls.set_hosts_cb) + cls.add_arg(None, "backend_service", cb=cls.set_hosts_cb) + cls.add_arg(None, "backend_connect_host", cb=cls.set_hosts_cb) + cls.add_arg(None, "backend_connect_service", cb=cls.set_hosts_cb) -ParserRNG.add_arg(None, "backend_host", cb=ParserRNG.set_hosts_cb) -ParserRNG.add_arg(None, "backend_service", cb=ParserRNG.set_hosts_cb) -ParserRNG.add_arg(None, "backend_connect_host", cb=ParserRNG.set_hosts_cb) -ParserRNG.add_arg(None, "backend_connect_service", cb=ParserRNG.set_hosts_cb) - -ParserRNG.add_arg("device", "device") -ParserRNG.add_arg("model", "model") -ParserRNG.add_arg("rate_bytes", "rate_bytes") -ParserRNG.add_arg("rate_period", "rate_period") + cls.add_arg("device", "device") + cls.add_arg("model", "model") + cls.add_arg("rate_bytes", "rate_bytes") + cls.add_arg("rate_period", "rate_period") ###################### @@ -2535,9 +2631,12 @@ class ParserWatchdog(VirtCLIParser): propname = "devices.watchdog" remove_first = "model" -_add_device_address_args(ParserWatchdog) -ParserWatchdog.add_arg("model", "model", ignore_default=True) -ParserWatchdog.add_arg("action", "action", ignore_default=True) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + _add_device_address_args(cls) + cls.add_arg("model", "model", ignore_default=True) + cls.add_arg("action", "action", ignore_default=True) #################### @@ -2552,15 +2651,18 @@ class ParserMemdev(VirtCLIParser): def set_target_size(self, inst, val, virtarg): _set_attribute(inst, virtarg.attrname, int(val) * 1024) -ParserMemdev.add_arg("model", "model") -ParserMemdev.add_arg("access", "access") -ParserMemdev.add_arg("target.size", "target_size", cb=ParserMemdev.set_target_size) -ParserMemdev.add_arg("target.node", "target_node") -ParserMemdev.add_arg("target.label_size", "target_label_size", - cb=ParserMemdev.set_target_size) -ParserMemdev.add_arg("source.pagesize", "source_pagesize") -ParserMemdev.add_arg("source.path", "source_path") -ParserMemdev.add_arg("source.nodemask", "source_nodemask", can_comma=True) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg("model", "model") + cls.add_arg("access", "access") + cls.add_arg("target.size", "target_size", cb=cls.set_target_size) + cls.add_arg("target.node", "target_node") + cls.add_arg("target.label_size", "target_label_size", + cb=cls.set_target_size) + cls.add_arg("source.pagesize", "source_pagesize") + cls.add_arg("source.path", "source_path") + cls.add_arg("source.nodemask", "source_nodemask", can_comma=True) ######################## @@ -2573,8 +2675,11 @@ class ParserMemballoon(VirtCLIParser): remove_first = "model" stub_none = False -_add_device_address_args(ParserMemballoon) -ParserMemballoon.add_arg("model", "model") + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + _add_device_address_args(cls) + cls.add_arg("model", "model") ################### @@ -2600,9 +2705,12 @@ class ParserPanic(VirtCLIParser): self.compat_mode = True return super()._parse(inst) -ParserPanic.add_arg(None, "model", cb=ParserPanic.set_model_cb, + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + cls.add_arg(None, "model", cb=cls.set_model_cb, ignore_default=True) -ParserPanic.add_arg("iobase", "iobase") + cls.add_arg("iobase", "iobase") ###################################################### @@ -2647,22 +2755,21 @@ class _ParserChar(VirtCLIParser): return super()._parse(inst) - -_add_device_address_args(_ParserChar) -_ParserChar.add_arg("type", "char_type") -_ParserChar.add_arg("source_path", "path") -_ParserChar.add_arg("protocol", "protocol") -_ParserChar.add_arg("target_type", "target_type") -_ParserChar.add_arg("target_name", "name") -_ParserChar.add_arg(None, "host", cb=_ParserChar.set_host_cb) -_ParserChar.add_arg(None, "bind_host", cb=_ParserChar.set_bind_cb) -_ParserChar.add_arg(None, "target_address", cb=_ParserChar.set_target_cb) -_ParserChar.add_arg("source_mode", "mode") -_ParserChar.add_arg("source_master", "source.master") -_ParserChar.add_arg("source_slave", "source.slave") -_ParserChar.add_arg("log_file", "log.file") -_ParserChar.add_arg("log_append", "log.append", is_onoff=True) - + @classmethod + def __init_class__(cls, **kwargs): + cls.add_arg("type", "char_type") + cls.add_arg("source_path", "path") + cls.add_arg("protocol", "protocol") + cls.add_arg("target_type", "target_type") + cls.add_arg("target_name", "name") + cls.add_arg(None, "host", cb=cls.set_host_cb) + cls.add_arg(None, "bind_host", cb=cls.set_bind_cb) + cls.add_arg(None, "target_address", cb=cls.set_target_cb) + cls.add_arg("source_mode", "mode") + cls.add_arg("source_master", "source.master") + cls.add_arg("source_slave", "source.slave") + cls.add_arg("log_file", "log.file") + cls.add_arg("log_append", "log.append", is_onoff=True) class ParserSerial(_ParserChar): @@ -2694,11 +2801,14 @@ class ParserFilesystem(VirtCLIParser): propname = "devices.filesystem" remove_first = ["source", "target"] -_add_device_address_args(ParserFilesystem) -ParserFilesystem.add_arg("type", "type") -ParserFilesystem.add_arg("accessmode", "accessmode", aliases=["mode"]) -ParserFilesystem.add_arg("source", "source") -ParserFilesystem.add_arg("target", "target") + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + _add_device_address_args(cls) + cls.add_arg("type", "type") + cls.add_arg("accessmode", "accessmode", aliases=["mode"]) + cls.add_arg("source", "source") + cls.add_arg("target", "target") ################### @@ -2724,14 +2834,17 @@ class ParserVideo(VirtCLIParser): return ret -_add_device_address_args(ParserVideo) -ParserVideo.add_arg("model", "model", ignore_default=True) -ParserVideo.add_arg("accel3d", "accel3d", is_onoff=True) -ParserVideo.add_arg("heads", "heads") -ParserVideo.add_arg("ram", "ram") -ParserVideo.add_arg("vram", "vram") -ParserVideo.add_arg("vram64", "vram64") -ParserVideo.add_arg("vgamem", "vgamem") + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + _add_device_address_args(cls) + cls.add_arg("model", "model", ignore_default=True) + cls.add_arg("accel3d", "accel3d", is_onoff=True) + cls.add_arg("heads", "heads") + cls.add_arg("ram", "ram") + cls.add_arg("vram", "vram") + cls.add_arg("vram64", "vram64") + cls.add_arg("vgamem", "vgamem") ################### @@ -2756,11 +2869,14 @@ class ParserSound(VirtCLIParser): cb = self._make_find_inst_cb(cliarg, objpropname) return cb(*args, **kwargs) -_add_device_address_args(ParserSound) -ParserSound.add_arg("model", "model", ignore_default=True) -# Options for sound.codecs config -ParserSound.add_arg("type", "codec[0-9]*.type", - find_inst_cb=ParserSound.codec_find_inst_cb) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + _add_device_address_args(cls) + cls.add_arg("model", "model", ignore_default=True) + # Options for sound.codecs config + cls.add_arg("type", "codec[0-9]*.type", + find_inst_cb=cls.codec_find_inst_cb) ##################### @@ -2790,14 +2906,17 @@ class ParserHostdev(VirtCLIParser): nodedev = NodeDevice.lookupNodedevFromString(inst.conn, val) return nodedev.compare_to_hostdev(inst) -_add_device_address_args(ParserHostdev) -ParserHostdev.add_arg("type", "type") -ParserHostdev.add_arg(None, "name", - cb=ParserHostdev.set_name_cb, - lookup_cb=ParserHostdev.name_lookup_cb) -ParserHostdev.add_arg("driver_name", "driver_name") -ParserHostdev.add_arg("boot.order", "boot_order") -ParserHostdev.add_arg("rom_bar", "rom_bar", is_onoff=True) + @classmethod + def __init_class__(cls, **kwargs): + super().__init_class__(**kwargs) + _add_device_address_args(cls) + cls.add_arg("type", "type") + cls.add_arg(None, "name", + cb=cls.set_name_cb, + lookup_cb=cls.name_lookup_cb) + cls.add_arg("driver_name", "driver_name") + cls.add_arg("boot.order", "boot_order") + cls.add_arg("rom_bar", "rom_bar", is_onoff=True) ########################### -- 2.17.0 _______________________________________________ virt-tools-list mailing list virt-tools-list@xxxxxxxxxx https://www.redhat.com/mailman/listinfo/virt-tools-list
