Add storage and image management support

Signed-off-by: Zhenchao Liu <[email protected]>

virttest/vt_agent/managers/__init__.py

@@ -0,0 +1,2 @@
+from .image_mgr import imgr
+from .resbacking_mgr import backing_mgr

virttest/vt_agent/managers/image_mgr.py

@@ -0,0 +1,16 @@
+from .images import get_image_handler
+
+
+class _ImageManager(object):
+
+    def __init__(self):
+        self._images = dict()
+
+    def update_image(self, image_config, update_cmd_config):
+        cmd, argument = list(update_cmd_config.items())[0]
+        image_type = image_config["meta"]["type"]
+        handler = get_image_handler(image_type, cmd)
+        handler.execute(image_config, argument)
+
+
+imgr = _ImageManager()

virttest/vt_agent/managers/images/__init__.py

@@ -0,0 +1,21 @@
+from .qemu.qemu_image_handlers import QEMU_IMAGE_TYPE, QemuImgCreate, QemuImgDestroy
+#from .xen.xen_image_handlers import XEN_IMAGE_TYPE, XenImgCreate, XenImgDestroy
+
+
+_image_handlers = dict()
+
+_image_handlers[QEMU_IMAGE_TYPE] = dict()
+_image_handlers[QEMU_IMAGE_TYPE][QemuImgCreate.cmd] = QemuImgCreate
+_image_handlers[QEMU_IMAGE_TYPE][QemuImgDestroy.cmd] = QemuImgDestroy
+
+#_image_handlers[XEN_IMAGE_TYPE] = dict()
+#_image_handlers[XEN_IMAGE_TYPE][XenImgCreate.cmd] = XenImgCreate
+#_image_handlers[XEN_IMAGE_TYPE][XenImgDestroy.cmd] = XenImgDestroy
+
+
+def get_image_handler(image_type, cmd):
+    handlers = _image_handlers.get(image_type, dict())
+    return handlers.get(cmd)
+
+
+__all__ = ["get_image_handler"]

virttest/vt_agent/managers/images/image_handlers.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+
+class _ImageHandler(ABC):
+    _COMMAND = None
+
+    @staticmethod
+    @abstractmethod
+    def execute(image_config, arguments):
+        raise NotImplemented
+
+    @classmethod
+    def command(cls):
+        return cls._COMMAND

virttest/vt_agent/managers/images/qemu/__init__.py

@@ -0,0 +1 @@
+import qemu_image_handlers

virttest/vt_agent/managers/images/qemu/qemu_image_handlers.py

@@ -0,0 +1,65 @@
+from ..image_handlers import _ImageHandler
+
+
+QEMU_IMAGE_TYPE = "qemu"
+
+
+class QemuImgCreate(_ImageHandler):
+    _COMMAND = "create"
+    create_cmd = (
+        "create {secret_object} {tls_creds_object} {image_format} "
+        "{backing_file} {backing_format} {unsafe!b} {options} "
+        "{image_filename} {image_size}"
+    )
+
+    @staticmethod
+    def execute(image_config, arguments):
+        pass
+
+
+class QemuImgDestroy(_ImageHandler):
+    _COMMAND = "destroy"
+
+    @staticmethod
+    def execute(image_config, arguments):
+        pass
+
+
+class QemuImgRebase(_ImageHandler):
+    _COMMAND = "rebase"
+
+    @staticmethod
+    def execute(image_config, arguments):
+        pass
+
+
+class QemuImgConvert(_ImageHandler):
+    _COMMAND = "convert"
+
+    @staticmethod
+    def execute(image_config, arguments):
+        pass
+
+
+class QemuImgCommit(_ImageHandler):
+    _COMMAND = "commit"
+
+    @staticmethod
+    def execute(image_config, arguments):
+        pass
+
+
+class QemuImgSnapshot(_ImageHandler):
+    _COMMAND = "snapshot"
+
+    @staticmethod
+    def execute(image_config, arguments):
+        pass
+
+    @staticmethod
+    def list(image_config, arguments):
+        pass
+
+    @staticmethod
+    def snap(image_config, arguments):
+        pass

virttest/vt_agent/managers/resbacking_mgr.py

@@ -0,0 +1,53 @@
+from .resbackings import get_resource_backing_class
+from .resbackings import get_pool_connection_class
+
+
+class _ResourceBackingManager(object):
+
+    def __init__(self):
+        self._pool_connections = dict()
+        self._backings = dict()
+
+    def create_pool_connection(self, pool_id, pool_conn_config):
+        pool_type = pool_conn_config["type"]
+        pool_conn_class = get_pool_connection_class(pool_type)
+        pool_conn = pool_conn_class(pool_conn_config)
+        pool_conn.startup()
+        self._pool_connections[pool_id] = pool_conn
+
+    def destroy_pool_connection(self, pool_id):
+        pool_conn = self._pool_connections[pool_id]
+        pool_conn.shutdown()
+        del self._pool_connections[pool_id]
+
+    def create_backing(self, config, need_allocate=False):
+        resource_id = config["uuid"]
+        pool_id = config["pool"]
+        pool_conn = self._pool_connections[pool_id]
+        res_type = config["type"]
+        backing_class = get_resource_backing_class(res_type)
+        backing = backing_class(config)
+        self._backings[backing.backing_id] = backing
+        if need_allocate:
+            backing.allocate(pool_conn)
+        return backing.backing_id
+
+    def destroy_backing(self, backing_id, need_release=False):
+        backing = self._backings[backing_id]
+        pool_conn = self._pool_connections[backing.source_pool]
+        if need_release:
+            backing.release(pool_conn)
+        del self._backings[backing_id]
+
+    def update_backing(self, backing_id, new_config):
+        backing = self._backings[backing_id]
+        pool_conn = self._pool_connections[backing.source_pool]
+        backing.update(pool_conn, new_config)
+
+    def info_backing(self, backing_id, request, verbose=False):
+        backing = self._backings[backing_id]
+        pool_conn = self._pool_connections[backing.source_pool]
+        return backing.query(pool_conn, request, verbose)
+
+
+backing_mgr = _ResourceBackingManager()

virttest/vt_agent/managers/resbackings/__init__.py

@@ -0,0 +1,17 @@
+from .storage import _DirPoolConnection, _DirVolumeBacking
+
+
+_pool_conn_classes = dict()
+_backing_classes = dict()
+#_pool_conn_classes[_CephPoolConnection.pool_type] = _CephPoolConnection
+_pool_conn_classes[_DirPoolConnection.pool_type] = _DirPoolConnection
+#_backing_classes[_CephVolumeBacking.resource_type] = _CephVolumeBacking
+_backing_classes[_DirVolumeBacking.resource_type] = _DirVolumeBacking
+
+
+def get_resource_backing_class(resource_type):
+    return _backing_classes.get(resource_type)
+
+
+def get_pool_connection_class(pool_type):
+    return _pool_conn_classes.get(pool_type)

virttest/vt_agent/managers/resbackings/backing.py

@@ -0,0 +1,40 @@
+import uuid
+from abc import ABC, abstractmethod
+
+
+class _ResourceBacking(ABC):
+    _RESOURCE_TYPE = None
+
+    def __init__(self, config):
+        self._uuid = uuid.uuid4()
+        self._config = config
+        self._source_pool = config["pool"]
+        self._resource_id = config["uuid"]
+
+    @property
+    def backing_id(self):
+        return self._uuid
+
+    @abstractmethod
+    def allocate(self, pool_connection):
+        pass
+
+    @abstractmethod
+    def release(self, pool_connection):
+        pass
+
+    @abstractmethod
+    def update(self, pool_connection, new_spec):
+        pass
+
+    @abstractmethod
+    def info(self, pool_connection):
+        pass
+
+    @classmethod
+    def resource_type(cls):
+        return cls._RESOURCE_TYPE
+
+    @property
+    def source_pool(self):
+        return self._source_pool

virttest/vt_agent/managers/resbackings/backing_mgr.py

@@ -0,0 +1,46 @@
+from abc import ABC, abstractmethod
+from .resbackings import get_backing_class
+from .resbackings import get_pool_connection_class
+
+
+class _ResourceBackingManager(ABC):
+    _ATTACHED_POOL_TYPE = None
+
+    def __init__(self):
+        self._pool_connections = dict()
+        self._backings = dict()
+
+    @abstractmethod
+    def create_pool_connection(self, pool_config):
+        pool_type = pool_config["type"]
+        pool_conn_class = get_pool_connection_class(pool_type)
+        pool_conn = pool_conn_class(pool_config)
+        pool_conn.startup()
+        self._pool_connections[pool_id] = pool_conn
+
+    def destroy_pool_connection(self, pool_id):
+        pool_conn = self._pool_connections[pool_id]
+        pool_conn.shutdown()
+        del self._pool_connections[pool_id]
+
+    @abstractmethod
+    def create_backing(self, config, need_allocate=False):
+        pass
+
+    def destroy_backing(self, backing_id, need_release=False):
+        backing = self._backings[backing_id]
+        pool_conn = self._pool_connections[backing.source_pool]
+        if need_release:
+            backing.release_resource(pool_conn)
+        del self._backings[backing_id]
+
+    def update_backing(self, backing_id, config):
+        backing = self._backings[backing_id]
+        pool_conn = self._pool_connections[backing.source_pool]
+        backing.update(pool_conn, config)
+
+    def get_backing(self, backing_id):
+        return self._backings.get(backing_id)
+
+    def info_backing(self, backing_id):
+        return self._backings[backing_id].to_specs()

virttest/vt_agent/managers/resbackings/cvm/__init__.py

@@ -0,0 +1,27 @@
+from .. import _CVMResBackingMgr
+from .. import _all_subclasses
+
+
+class LaunchSecurity(object):
+    _instance = None
+
+    @classmethod
+    def dispatch(cls):
+        return cls._instance
+
+    @classmethod
+    def startup(cls, config):
+        if cls._instance is not None:
+            return cls._instance
+
+        for mgr_cls in _all_subclasses(_CVMResBackingMgr):
+            if mgr_cls.get_platform_flags() is not None:
+                cls._instance = mgr_cls(config)
+                cls._instance.startup()
+                return cls._instance
+
+        raise
+
+    @classmethod
+    def teardown(cls):
+        cls._instance.teardown()