Add storage and image management support

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

virttest/vt_agent/managers/image/__init__.py

@@ -0,0 +1 @@
+from .dispatcher import _image_handler_dispatcher

virttest/vt_agent/managers/image/dispatcher.py

@@ -0,0 +1,20 @@
+from .qemu import _qemu_image_handler
+
+# from .xen import _xen_image_handler
+
+
+class _ImageHandlerDispatcher(object):
+
+    def __init__(self):
+        self._managers_mapping = dict()
+        self._backings_mapping = dict()
+        self._pools_mapping = dict()
+
+    def dispatch(self, key):
+        return
+
+
+_image_handler_dispatcher = _ImageHandlerDispatcher()
+
+_image_handler_dispatcher.register(_qemu_image_handler)
+# _image_handler_dispatcher.register(_xen_image_handler)

virttest/vt_agent/managers/image/image_handler.py

@@ -0,0 +1,40 @@
+from abc import ABC, abstractmethod
+
+
+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_access_config):
+        pass
+
+    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/image/qemu/__init__.py

@@ -0,0 +1 @@
+from .dir import _dir_backing_mgr

virttest/vt_agent/managers/image/qemu/qemu_image_handler.py

@@ -0,0 +1,16 @@
+class _QemuImageHandler(_ImageHandler):
+
+    def convert(self, source_spec, target_spec):
+        pass
+
+    def commit(self, top_spec, backing_spec):
+        pass
+
+    def create(self, image_spec):
+        pass
+
+    def destroy(self, image_spec):
+        pass
+
+    def info(self, image_spec):
+        pass

virttest/vt_agent/managers/resbackings/__init__.py

@@ -0,0 +1 @@
+from .dispatcher import _resbacking_mgr_dispatcher

virttest/vt_agent/managers/resbackings/backing.py

@@ -0,0 +1,38 @@
+import uuid
+from abc import ABC, abstractmethod
+
+
+class _ResourceBacking(ABC):
+    _RESOURCE_TYPE = None
+
+    def __init__(self, config):
+        self._uuid = uuid.uuid4()
+        self._source_pool = config["spec"]["pool_id"]
+
+    @property
+    def uuid(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
+
+    @property
+    def resource_type(self):
+        return self._RESOURCE_TYPE
+
+    @property
+    def source_pool(self):
+        return self._source_pool

virttest/vt_agent/managers/resbackings/backing_mgr.py

@@ -0,0 +1,40 @@
+from abc import ABC, abstractmethod
+
+
+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_access_config):
+        pass
+
+    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()

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

@@ -0,0 +1,98 @@
+from .. import _ResBacking
+from .. import _ResBackingCaps
+from .. import _CVMResBackingMgr
+
+
+class _SEVCommResBacking(_ResBacking):
+
+    def __init__(self, requests):
+        super().__init__(requests)
+        self._cbitpos = None
+        self._reduced_phys_bits = None
+        # self._sev_device = '/dev/sev'
+        # self._kernel_hashes = None
+
+    def to_specs(self):
+        return {"cbitpos": self._cbitpos, "reduced-phys-bits": self._reduced_phys_bits}
+
+
+class _SEVResBacking(_SEVCommResBacking):
+    RESOURCE_TYPE = "sev"
+
+    def __init__(self):
+        super().__init__()
+        self._dh_cert = None
+        self._session = None
+
+    def allocate(self, requests):
+        pass
+
+    def free(self):
+        pass
+
+    def to_specs(self):
+        pass
+
+
+class _SNPResBacking(_SEVCommResBacking):
+    RESOURCE_TYPE = "snp"
+
+    def __init__(self):
+        super().__init__()
+
+    def allocate(self, requests):
+        pass
+
+    def free(self):
+        pass
+
+    def to_specs(self):
+        pass
+
+
+class _SEVResBackingCaps(_ResBackingCaps):
+
+    def __init__(self, params):
+        self._cbitpos = None
+        self._reduced_phys_bits = None
+        self._sev_device = None
+        self._max_sev_guests = None
+        self._max_snp_guests = None
+        self._pdh = None
+        self._cert_chain = None
+        self._cpu0_id = None
+
+    def load(self):
+        pass
+
+    def is_capable(self, requests):
+        pass
+
+    def increase(self, backing):
+        pass
+
+    def decrease(self, backing):
+        pass
+
+    @property
+    def max_sev_guests(self):
+        return self._max_sev_guests
+
+    @property
+    def max_snp_guests(self):
+        return self._max_snp_guests
+
+
+class _SEVResBackingMgr(_CVMResBackingMgr):
+
+    def __init__(self, config):
+        super().__init__(config)
+        self._caps = _SEVResBackingCaps(config)
+        _SEVResBackingMgr._platform_flags = config
+
+    def startup(self):
+        reset_sev_platform()
+        super().startup()
+
+    def teardown(self):
+        reset_sev_platform()

virttest/vt_agent/managers/resbackings/cvm_platform_mgr/_sev_platform_mgr.py

@@ -0,0 +1,6 @@
+def reset_platform():
+    pass
+
+
+def rotate_pdh():
+    pass

virttest/vt_agent/managers/resbackings/cvm_platform_mgr/_tdx_platform_mgr.py

@@ -0,0 +1,6 @@
+def reset_platform():
+    pass
+
+
+def rotate_pdh():
+    pass

virttest/vt_agent/managers/resbackings/dispatcher.py

@@ -0,0 +1,49 @@
+from .storage import _dir_backing_mgr
+from .storage import _nfs_backing_mgr
+
+# from .storage import _ceph_backing_mgr
+# from .cvm import _sev_backing_mgr
+# from .cvm import _tdx_backing_mgr
+
+
+class _BackingMgrDispatcher(object):
+
+    def __init__(self):
+        self._managers_mapping = dict()
+        self._backings_mapping = dict()
+        self._pools_mapping = dict()
+
+    def dispatch_by_pool(self, pool_id):
+        return self._pools_mapping.get(pool_id, None)
+
+    def dispatch_by_backing(self, backing_id):
+        return self._backings_mapping.get(backing_id, None)
+
+    @classmethod
+    def register(cls, mgr):
+        self._managers_mapping[mgr.attached_pool_type] = mgr
+
+    def map_pool(self, pool_id, pool_type):
+        backing_mgr = self._managers_mapping[pool_type]
+        self._pools_mapping[pool_id] = backing_mgr
+
+    def unmap_pool(self, pool_id):
+        del self._pools_mapping[pool_id]
+
+    def map_backing(self, backing_id, backing_mgr):
+        self._backings_mapping[backing_id] = backing_mgr
+
+    def unmap_backing(self, backing_id):
+        del self._backings_mapping[backing_id]
+
+
+_backing_mgr_dispatcher = _BackingMgrDispatcher()
+
+# Register storage backing managers
+_backing_mgr_dispatcher.register(_dir_backing_mgr)
+_backing_mgr_dispatcher.register(_nfs_backing_mgr)
+# _backing_mgr_dispatcher.register(_ceph_backing_mgr)
+
+# Register cvm backing managers
+# _backing_mgr_dispatcher.register(_sev_backing_mgr)
+# _backing_mgr_dispatcher.register(_tdx_backing_mgr)

virttest/vt_agent/managers/resbackings/pool_connection.py

@@ -0,0 +1,27 @@
+import uuid
+from abc import ABC, abstractmethod
+
+
+class _ResourcePoolAccess(ABC):
+
+    @abstractmethod
+    def __init__(self, pool_access_config):
+        pass
+
+
+class _ResourcePoolConnection(ABC):
+
+    def __init__(self, pool_config, pool_access_config):
+        self._connected_pool = pool_config["pool_id"]
+
+    @abstractmethod
+    def startup(self):
+        pass
+
+    @abstractmethod
+    def shutdown(self, backing):
+        pass
+
+    @abstractmethod
+    def connected(self):
+        return False

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

@@ -0,0 +1,2 @@
+from .dir import _dir_backing_mgr
+from .nfs import _nfs_backing_mgr

virttest/vt_agent/managers/resbackings/storage/dir/__init__.py

@@ -0,0 +1 @@
+from .dir_backing_mgr import _dir_backing_mgr