maqet 0.0.1.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

maqet/core.py

@@ -1,395 +0,0 @@
-import argparse
-import time
-from functools import wraps
-from pathlib import Path
-from typing import Callable, List
-
-from benedict import benedict
-
-from qemu.machine import QEMUMachine
-
-from .functions import parse_args, split_args
-from .logger import LOG
-from .storage import DRIVE_TYPES, Drive
-
-# To be moved into input.py
-SPEC_CHAR_KEYS = {
-    "\r": ["ret"],
-    "\n": ["ret"],
-    " ": ["spc"],
-    "=": ["equal"],
-    "+": ["shift", "equal"],
-    "-": ["minus"],
-    "_": ["shift", "minus"],
-    ";": ["semicolon"],
-    ":": ["shift", "semicolon"],
-    "&": ["shift", "7"],
-    "/": ["slash"],
-    ".": ["dot"],
-    ">": ["shift", "dot"],
-    "<": ["shift", "comma"],
-    "#": ["shift", "3"],
-}
-
-
-class MaqetError(Exception):
-    """
-    General exception
-    """
-
-
-class MachineError(Exception):
-    """
-    Machine generic error
-    """
-
-
-class Machine(QEMUMachine):
-    def __init__(self, *args, **kwargs):
-        """
-        TODO: make docstring
-
-        Machine objects should be created with **kwargs
-        """
-        self._config = benedict(kwargs)
-        if 'storage_path' in self._config:
-            self._config.storage_path = Path(self._config.storage_path)
-        if 'binary' not in self._config:
-            raise MachineError("Binary not stated in config")
-
-        self._config.typing_delay = kwargs.get('typing_delay', 0.1)
-
-        binary = self._config['binary']
-
-        qemumachine_args = dict()
-        for key in ['args', 'wrapper', 'name', 'base_temp_dir',
-                    'monitor_address', 'drain_console', 'console_log',
-                    'log_dir', 'qmp_timer']:
-            if key in self._config:
-                qemumachine_args[key] = self._config[key]
-
-        super().__init__(binary=binary, **qemumachine_args)
-
-        self.storage = dict()
-        if 'storage' in self._config:
-            for name, drive in self._config.storage.items():
-                self.add_drive(name=name, **drive)
-
-    def launch(self):
-        LOG.info(f'VM launch with command: {self.command}')
-        super().launch()
-
-    def add_drive(self, name, **kwargs) -> None:
-        if 'path' not in kwargs:
-            if 'storage_path' in self._config:
-                # Adding default storage path from config
-                kwargs['path'] = self._config.storage_path / name
-            else:
-                raise MachineError(
-                    'Cannot add drive: stated neither path nor storage_path')
-        self.storage[name] = Drive(**kwargs)
-
-    # def add_argument(self, argument: str) -> None:
-    #     """
-    #     Add user argument to VM config
-    #     """
-    #     self._config['user_arguments'].append(argument)
-
-    def add_args(self, *args: str) -> None:
-        """
-        Adds to the list of extra arguments to be given to the QEMU binary
-        """
-        super().add_args(*split_args(args))
-
-    @property
-    def command(self) -> str:
-        """
-        get full command string that will be executed at start
-        """
-        return self._binary + ' ' + ' '.join(self._base_args)
-
-    @property
-    def _const_args(self) -> List[str]:
-        if 'arguments' not in self._config:
-            return []
-        return parse_args(self._config.arguments)
-
-    @property
-    def _var_args(self) -> List[str]:
-        # TODO:more reliable method. Maybe add-fd?
-
-        args = []
-        for id, drive in self.storage.items():
-            args += drive()
-
-        return [
-            a_splitted
-            for a in args
-            for a_splitted in a.split()
-        ]
-
-    @property
-    def user_args(self):
-        return [
-            a_splitted
-            for a in self._config.user_arguments
-            for a_splitted in a.split()
-        ]
-
-    @ property
-    def _base_args(self):
-        args = self._var_args + self._const_args + self.user_args
-
-        if self._qmp_set:
-            if self._sock_pair:
-                moncdev = f"socket,id=mon,fd={self._sock_pair[0].fileno()}"
-            elif isinstance(self._monitor_address, tuple):
-                moncdev = "socket,id=mon,host={},port={}".format(
-                    *self._monitor_address
-                )
-            else:
-                moncdev = f"socket,id=mon,path={self._monitor_address}"
-            args.extend(['-chardev', moncdev, '-mon',
-                         'chardev=mon,mode=control'])
-
-        if self._machine is not None:
-            args.extend(['-machine', self._machine])
-        for _ in range(self._console_index):
-            args.extend(['-serial', 'null'])
-        if self._console_set:
-            assert self._cons_sock_pair is not None
-            fd = self._cons_sock_pair[0].fileno()
-            chardev = f"socket,id=console,fd={fd}"
-            args.extend(['-chardev', chardev])
-            if self._console_device_type is None:
-                args.extend(['-serial', 'chardev:console'])
-            else:
-                device = '%s,chardev=console' % self._console_device_type
-                args.extend(['-device', device])
-        return args
-
-    def send_keys(self, keys: list[str] = []) -> dict:
-        LOG.debug(f"QMP: keys to input: {keys}")
-        command = "input-send-event"
-
-        arguments = benedict({"events": []})
-        arguments.events = []
-
-        for k in keys:
-            arguments.events.append(benedict(
-                {
-                    "type": "key",
-                    "data": {"down": True, "key":
-                             {"type": "qcode", "data": k}},
-                }
-            ))
-
-        r = self.qmp(cmd=command, args_dict=arguments)
-        LOG.debug(f"QMP: {keys}")
-
-        for e in arguments.events:
-            e.data.down = False
-
-        r = self.qmp(cmd=command, args_dict=arguments)
-        LOG.debug(f"QMP: {keys}")
-        return r
-
-    def send_input(self, string: str = "",):
-        """
-        Send input string to VM by emulating key press events
-        """
-        chars = list(string)
-
-        for c in chars:
-            keys = []
-            if c in SPEC_CHAR_KEYS.keys():  # Enter
-                keys = SPEC_CHAR_KEYS[c]
-            elif c.isnumeric():  # Numbers
-                keys.append(c)
-            elif c.isalpha():  # Letters
-                if c.isupper():
-                    keys.append('shift')
-                keys.append(c.lower())
-
-            LOG.debug(f"Sending keys: {keys}")
-            self.send_keys(keys=keys)
-            time.sleep(self._config.typing_delay)
-
-    def qmp_command(self, command_name: str = None, verbose=False,
-                    *args, **kwargs) -> dict:
-        """
-        Execute custom or pre-cooked qmp command from config.qmp_commands
-        """
-        # TODO: add kwargs usage for templating cooked commands
-        if command_name is None:
-            command = kwargs
-        else:
-            if 'qmp_commands' not in self._config:
-                raise MachineError('qmp_commands not stated in config')
-            if command_name not in self._config.qmp_commands:
-                raise MachineError('qmp command not stated qmp_commands')
-            command = self._config.qmp_commands[command_name]
-
-        if 'execute' not in command:
-            raise MachineError(
-                'qmp command: execute key and value not found')
-
-        if 'arguments' in command:
-            r = self.qmp(cmd=command.execute, args_dict=command.arguments)
-        else:
-            r = self.qmp(cmd=command.execute)
-
-        if verbose:
-            LOG.debug(f"QMP: {command}\nRETURN: {r}")
-        return r
-
-    def shutdown(self, *args, **kwargs):
-        """
-        Perform shutdown if machine is running
-        """
-        if self.is_running():
-            super().shutdown(*args, **kwargs)
-
-
-class Maqet:
-    """
-    TODO
-    """
-
-    def __init__(self, *args, **kwargs) -> None:
-        self.Machine = Machine  # For comfortable stage building
-        self._config = benedict(kwargs)
-
-        self._stages = dict()
-        self.storage: dict[str, Drive] = dict()
-
-    def __call__(self, *args, **kwargs) -> None:
-        # Start pipeline
-
-        LOG.info(f"Stages to run: {args}")
-
-        for stage in args:
-            if stage in self._stages:
-                LOG.info(f"Executing stage {stage}")
-                with self.Machine(**self._config.deepcopy()) as vm:
-                    self._stages[stage](vm)
-            else:
-                LOG.warning(f"Stage {stage} not found. Skipping")
-
-    @property
-    def command(self) -> str:
-        """
-        get full command string that will be executed at start
-        """
-        with self.Machine(**self._config) as vm:
-            return vm.command
-
-    @property
-    def DRIVE_TYPES(self) -> list:
-        """
-        Get available drive types
-        """
-        return list(DRIVE_TYPES)
-
-    @property
-    def config(self) -> dict:
-        return self._config
-
-    @config.setter
-    def set_config(self, new_config: dict):
-        self._config = benedict(new_config)
-
-    def merge_config(self, new_config: dict):
-        self._config.merge(new_config)
-
-    def add_argument(self, argument: str) -> None:
-        """
-        Add user argument to config.
-        It will be added to Machine arguments in every stage
-        """
-        self._config['user_arguments'].append(argument)
-
-    def stage(self, stage_func: Callable, *args, **kwargs) -> Callable:
-        """
-        Include function as stage into Maqet pipeline. Does not modify function
-        """
-        self._stages[stage_func.__name__] = lambda vm: stage_func(vm)
-
-        @ wraps
-        def wrapper(*args, **kwargs):
-            raise MaqetError(
-                "Do not call stage functions by themselves, "
-                f"call {self.__class__}(<stage function name>)"
-                f"or {self.__class__}.cli() "
-                "and enter stages as positional args"
-            )
-        return wrapper
-
-    def cli(self, *args, **kwargs) -> None:
-        """
-        Run Maqet in Command Line Interface mode
-        """
-        parser = argparse.ArgumentParser()
-
-        parser.add_argument(
-            "stage",
-            nargs="*",
-            help="stages to run. If not stated - "
-            "start VM with given config and wait for shutdown",
-        )
-        parser.add_argument(
-            "-c", "--config-file",
-            help="Set yaml file as a config",
-            required=False,
-            default=None,
-            type=Path,
-        )
-        parser.add_argument(
-            "-a", "--argument",
-            help="State additional argument for qemu binary",
-            action="append",
-            default=[],
-            # nargs="*",
-        )
-        parser.add_argument(
-            "-s", "--storage-path",
-            help="Set default path for drives",
-            required=False,
-            type=Path,
-            default=None
-        )
-        parser.add_argument(
-            "-v", "--verbose",
-            action='count',
-            help="increase verbose level",
-            default=0
-        )
-        parser.add_argument(
-            "--command",
-            action='store_true',
-            help="Output command with config and exit",
-            default=False
-        )
-
-        cli_args = parser.parse_args()
-        LOG.setLevel(50 - cli_args.verbose *
-                     10 if cli_args.verbose < 5 else 10)
-
-        LOG.info(cli_args)
-
-        if cli_args.storage_path is not None:
-            self._config.storage_path = cli_args.storage_path
-        if cli_args.config_file is not None:
-            self.merge_config(
-                benedict.from_yaml(cli_args.config_file.resolve())
-            )
-        if len(cli_args.argument) > 0:
-            for a in cli_args.argument:
-                self.add_argument(a)
-        if cli_args.command:
-            print(self.command)
-            exit(0)
-
-        self(
-            *cli_args.stage,
-        )

maqet/functions.py

@@ -1,104 +0,0 @@
-import logging
-import subprocess
-from pathlib import Path
-from typing import List
-
-from benedict import benedict
-
-from .logger import LOG
-
-
-def shell_command(command: str, verbose: bool = True) -> benedict:
-    """
-    Run shell command and return dictionary of stdout, stderr, returncode
-    Return is benedict object, members can be accessed as fields
-    """
-    command = " ".join(command.split())
-
-    proc = subprocess.Popen(command, shell=True,
-                            stdout=subprocess.PIPE,
-                            stderr=subprocess.PIPE)
-    out = proc.communicate()
-
-    output = benedict({
-        "stdout": out[0].decode('ascii').strip("\n"),
-        "stderr": out[1].decode('ascii').strip("\n"),
-        "rc": proc.returncode
-    })
-
-    message = f"command `{command}` returned {output}"
-
-    if verbose:
-        level = logging.DEBUG
-        if output.stderr != '':
-            level = logging.WARNING
-        if output.rc != 0:
-            level = logging.ERROR
-
-        LOG.log(level, message)
-    return output
-
-
-def mount_disk_to_host(path: Path) -> Path:
-    return Path(shell_command(f"""
-        udiskie-mount {str(path)} | grep mounted |\
-        grep -o 'on .*$' | sed 's/on //'
-    """).stdout)
-
-
-def split_args(args: List):
-    """
-    Split args by spaces, used to send them into qemu methods
-    """
-    return [
-        a_splitted
-        for a in args
-        for a_splitted in a.split()
-    ]
-
-
-def parse_options(arg, stack=[], key_only=False):
-    if not isinstance(arg, (list, dict)):
-        if len(stack) > 0:
-            if key_only:
-                return '.'.join(stack) + f'.{arg}'
-            else:
-                return '.'.join(stack) + f'={arg}'
-        else:
-            return arg
-
-    options = []
-    if isinstance(arg, list):
-        for v in arg:
-            if isinstance(arg, (list, dict)):
-                options.append(parse_options(v, stack, key_only=True))
-            else:
-                options.append('.'.join(stack) + f'.{v}')
-
-    elif isinstance(arg, dict):
-        for k, v in arg.items():
-            if isinstance(arg, (list, dict)):
-                options.append(parse_options(v, stack+[k], key_only=False))
-            else:
-                option = '.'.join(stack) + f'={v}'
-                options.append(option)
-    return ','.join(options)
-
-
-def parse_args(args: list) -> List[str]:
-    final_args = []
-
-    for arg in args:
-        if type(arg) is str:
-            argument = f'-{arg}'
-        else:
-            al = list(arg.items())
-            if len(al) == 1:
-                argument = f"-{al[0][0]} {parse_options(al[0][1])}"
-            else:
-                subarg = arg.copy()
-                del subarg[al[0][0]]
-                argument = f"-{al[0][0]} {al[0][1]},{parse_options(subarg)}"
-        final_args.append(argument)
-
-    return split_args(final_args)

maqet-0.0.1.3.dist-info/METADATA

@@ -1,104 +0,0 @@
-Metadata-Version: 2.1
-Name: maqet
-Version: 0.0.1.3
-Project-URL: Repository, https://gitlab.com/m4x0n_24/maqet/-/tree/main
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-Requires-Dist: python-benedict >=0.33.2
-
-# MAQET
-
-**Work in progress.** Documentation and code can be absolute mess.
-
-If you are willing to help - open issue, MR or do something else
-to attract maintainer's attention
-
-## Description
-
-MAQET stands for M4x0n QEmu Tool.
-It's based on [QEMU](https://gitlab.com/qemu-project/qemu) python [tooling](https://gitlab.com/qemu-project/qemu/-/tree/master/python?ref_type=heads).
-
-Main goal of this project is to provide good way to run qemu virtual machine.
-Author (m4x0n) wants to create virtual environment for repeatable testing
-of Linux installation and configuration before messing around with real computer,
-so all features implemented are primarily pursuing this goal.
-
-### Roadmap
-
-First usable version:
-
-- [x] YAML manifest for VM settings
-- [x] Storage (-drive) management:
-  - [x] RAW and QCOW2 files
-  - [x] Using backing images for QCOW2
-  - [x] Internal snapshots for QCOW2
-- [x] Stages defined as python functions with decorator (Flask style)
-- [x] CLI to specify stage, additional arguments and options
-- [x] QMP commands
-
-Goals for near future (sorted by priority):
-
-- [ ] Unified naming of variables (what is config? What is manifest?)
-- [ ] Code cleanup, adding typing hints, docstrings etc.
-- [ ] Extensible system of kwargs handling in every class (see in dev notes)
-- [ ] Unit tests
-- [ ] Full translation of strings into QMP key inputs
-
-Advanced goals
-
-- [ ] Custom QMP command presets
-- [ ] Advanced storage management
-- [ ] Runtime snapshots via qmp
-- [ ] Remote storage types (iscsi)
-
-## Usage guide
-
-See [example](https://gitlab.com/m4x0n_24/maqet/-/tree/main/example)
-Full documentation will be later
-
-## Development notes
-
-### Unification of **kwargs handling in extensible way
-
-Problem: classes have *args and **kwargs arguments. It gives flexibility,
-but also makes argument handling cumbersome (Ladder of if statements).
-
-Main class - Maqet, get it's kwargs and uses them as a config,
-parses and creates Machine class object
-with relevant arguments, also in form of kwargs.
-
-Idea is to make it extensible and unified. Like this:
-
-```yaml
-binary: qemu-system-x86_64
-arguments:
-  - foo
-  - bar
-  - baz
-storage:
-  - hda:
-      size: 5G
-      type: qcow2
-      options:
-        id: sda
-      ...
-some_custom_field:
-  - memory: 8G
-  - cpu: 4
-  - print: I_LIKE_PONIES
-```
-
-Binary is easy, just pass it into Machine
-What about arguments? Also pass into Machie, I made parser that turn them
-into cli arguments for qemu binary
-Storage? Call object Storage for every object in the list and pass contents inside
-Custom field? It will be ignored. If we want to use it?
-For example:
-We want to turn `memory: 8G, cpu: 4` into `-m 8G -smp 4`
-and run `print("I_LIKE_PONIES")` before VM starts.
-So we need somehow to extend Maqet class. How to do it? Still not sure.
-
-### QEMU not in PyPI
-
-Now QEMU tooling for python is used as sparse-checkouted git submodule.

maqet-0.0.1.3.dist-info/RECORD

@@ -1,33 +0,0 @@
-maqet/__init__.py,sha256=hH-7x9aitvZKK46YFjdGLvHRSGMl67QLWwYlzikeoRw,96
-maqet/core.py,sha256=7SjZaVNWsZG7Sp2lw_UcrMKInWHMsprpq9nnnyiEi8s,11841
-maqet/functions.py,sha256=gZRIeCZpalnK6T9ktDzGHIT8LzniXaEMdzFNVTccXOo,2856
-maqet/logger.py,sha256=3N9TnInogdYVZ7DrT6Cg6lL8Q-c6AufBDspy9RmLWhk,1821
-maqet/storage.py,sha256=09atk3-eMf2xH-CGdwrr9D-zHMPXkaLXT1AIjZ6WMxI,6273
-qemu/machine/__init__.py,sha256=X8_E5OIwoB8zsmqb8mJGOozzSlm5zujaJih6I12BBdg,945
-qemu/machine/console_socket.py,sha256=uZdScPgbtQXjAtzpBIpXwLuLgMj6MMblaOj4jLjYaEM,5314
-qemu/machine/machine.py,sha256=wXb2TmPfS9HOC5HoCKhZ0pwcXolqDNi10YmCQs14sCU,32965
-qemu/machine/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qemu/machine/qtest.py,sha256=ELhoX5pSIL4jeUZjlT5oh5wty4zOTdcfasAjTBxel1Y,5926
-qemu/qmp/__init__.py,sha256=Gz9qHFm1IPfva9CmBOT1H4MjBygpzXTK-JrHP0ba71E,1545
-qemu/qmp/error.py,sha256=tCa_0PXVfGfj0-U88WzYnIpSVoo2kCnvyEZWh0hMp0A,1701
-qemu/qmp/events.py,sha256=ztOo_BbzLJZC3_X0EV4BhY5ibNt0CjnGVWAWEmTTiVk,22653
-qemu/qmp/legacy.py,sha256=zogqHC05n8RineXAD68iEP6K6RQFMZTlwx9wSpq3zvc,9962
-qemu/qmp/message.py,sha256=HxYZ5XguixBi1G6xXrKI5NQLekxzdPuOLxeWpz9Qhxw,6355
-qemu/qmp/models.py,sha256=mz3oDKmHUjro9vFDreooD0PucNFU4tCKJVYxTFfWdN8,4418
-qemu/qmp/protocol.py,sha256=d-3pInzEUJqI_RlM6IOOyYCOruEEfLm0U96NIjZa1OA,38506
-qemu/qmp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qemu/qmp/qmp_client.py,sha256=LqHwh1cFUcgr8kWYBo9Z1XIlrMNypL9_4xeLQ9kRdGk,22584
-qemu/qmp/qmp_shell.py,sha256=LbI2bIlrGLbKIbLSeGyoxA_Vh4Eb1j3R8fqYxLqrP6c,19897
-qemu/qmp/qmp_tui.py,sha256=DRq2VhEqG8WkyQ7OdPVKYvJYi502WDpmHQDbISU4Rac,22318
-qemu/qmp/util.py,sha256=A2ThMPFtt6CpqNGPa4F6T2D4vmhTcyEPGe8vjBV9Bbk,6231
-qemu/utils/__init__.py,sha256=hC2_82OPDhVTKE6UUG_bsuBVDkqjwD7LArxBxuzu8BY,5646
-qemu/utils/accel.py,sha256=jOuuDLXyJMjZX9Uae-XnhNdYFnrXMlaGaUlxyCNntwU,2348
-qemu/utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qemu/utils/qemu_ga_client.py,sha256=ycQ6lOh7Q0DEwvNq_LyE0Y4DRZfimq8kjhNlyn3K0Zk,9484
-qemu/utils/qom.py,sha256=sC2wXMZ_dH4E5HnYinjCMpagx_I-9NJ5oJi0rEiqqQQ,7564
-qemu/utils/qom_common.py,sha256=UQitmqLNGYfd3DoMaLNxRprgJeaEs6hX-8mrhGQ2mkc,4991
-qemu/utils/qom_fuse.py,sha256=uDbTKVWWej1Ey1Jsnw2p9sjmuLC_2vBBtBZpPG40I-k,5966
-maqet-0.0.1.3.dist-info/METADATA,sha256=lkT0rMHt-c6_DXT-HjQPZFULSEHIzceQqsBMSw24Oo4,3154
-maqet-0.0.1.3.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
-maqet-0.0.1.3.dist-info/top_level.txt,sha256=9J0eHJ7TIdifxVkOxhgWVSyxkKRQhuFcbqUzIjhmgWg,11
-maqet-0.0.1.3.dist-info/RECORD,,

qemu/machine/__init__.py

@@ -1,36 +0,0 @@
-"""
-QEMU development and testing library.
-
-This library provides a few high-level classes for driving QEMU from a
-test suite, not intended for production use.
-
- | QEMUQtestProtocol: send/receive qtest messages.
- | QEMUMachine: Configure and Boot a QEMU VM
- | +-- QEMUQtestMachine: VM class, with a qtest socket.
-
-"""
-
-# Copyright (C) 2020-2021 John Snow for Red Hat Inc.
-# Copyright (C) 2015-2016 Red Hat Inc.
-# Copyright (C) 2012 IBM Corp.
-#
-# Authors:
-#  John Snow <jsnow@redhat.com>
-#  Fam Zheng <fam@euphon.net>
-#
-# This work is licensed under the terms of the GNU GPL, version 2.  See
-# the COPYING file in the top-level directory.
-#
-
-# pylint: disable=import-error
-# see: https://github.com/PyCQA/pylint/issues/3624
-# see: https://github.com/PyCQA/pylint/issues/3651
-from .machine import QEMUMachine
-from .qtest import QEMUQtestMachine, QEMUQtestProtocol
-
-
-__all__ = (
-    'QEMUMachine',
-    'QEMUQtestProtocol',
-    'QEMUQtestMachine',
-)