refactor(compute): migrate MachinePool driver_spec to KindModelSelectorType

- Replace free-form dict driver_spec with discriminated union of
  LibvirtPoolDriverSpec, ExordosLocalHyperDriverSpec and
  DummyPoolDriverSpec kind models
- Add ExordosLocalHyperDriverSpec extending LibvirtPoolDriverSpec
  with required node field for local hypervisor support
- Register LocalPoolAgentDriver with local_pool capability
- Update LibvirtPoolDriver to accept LibvirtPoolDriverSpec subclasses
- Update DummyPoolDriver and MetaPool in agent driver to use typed spec
- Fix bootstrap code to use attribute access for connection_uri
- Remove obsolete driver_spec filter in scheduler (now always required)
- Add pool scheduling logic: exordos_local_hyper pools scheduled on
  agents with matching node; regular pools exclude local agents
- Add migration to rename "driver" key to "kind" in existing data
  and update updated_at to propagate changes to data plane
- Update test fixtures and tests to use new "kind" format
- Add unit tests for local/regular pool scheduling logic

Signed-off-by: Anton Kremenetsky <anton.kremenetsky@gmail.com>

Author: akremenetsky

exordos_core/bootstrap/defaults.py

@@ -402,10 +402,7 @@ def apply_startup_db(spec: dict[str, tp.Any]) -> None:
 
         # Skip if the pool already exists
         for _pool in machine_pools:
-            if (
-                _pool.driver_spec["connection_uri"]
-                == pool.driver_spec["connection_uri"]
-            ):
+            if _pool.driver_spec.connection_uri == pool.driver_spec.connection_uri:
                 break
         else:
             # Pool does not exist, create it

exordos_core/cmd/bootstrap.py

@@ -30,7 +30,6 @@
 from oslo_config import cfg
 from restalchemy.common import config_opts as ra_config_opts
 from restalchemy.dm import filters as dm_filters
-from restalchemy.storage import exceptions as ra_exceptions
 from restalchemy.storage.sql import engines
 import yaml
 
@@ -177,50 +176,6 @@ def _apply_flat_network(stand: dict[str, tp.Any]) -> None:
         LOG.info("Created subnet %s", subnet.uuid)
 
 
-def _apply_startup_db(spec: dict[str, tp.Any]) -> None:
-    """Idempotent startup database configuration."""
-    stand = spec.get("stand", {})
-    if not stand:
-        LOG.info("No `stand` section found in %s", spec)
-        return
-
-    # Apply flat network configuration
-    _apply_flat_network(stand)
-
-    # Apply machine pools
-    # NOTE(akremenetsky): It maybe a problem for large installations
-    # with many machine pools, but it's fine for now.
-    machine_pools = models.MachinePool.objects.get_all()
-
-    for hypervisor in stand.get("hypervisors", []):
-        hypervisor["iface_mtu"] = 1500
-        pool_data = {
-            "name": "hypervisor",
-            "machine_type": "VM",
-            "driver_spec": hypervisor,
-        }
-        pool = models.MachinePool.restore_from_simple_view(**pool_data)
-
-        # Skip if the pool already exists
-        for _pool in machine_pools:
-            if (
-                _pool.driver_spec["connection_uri"]
-                == pool.driver_spec["connection_uri"]
-            ):
-                break
-        else:
-            # Pool does not exist, create it
-            try:
-                pool.insert()
-            except ra_exceptions.ConflictRecords:
-                LOG.info("Machine pool %s already exists", pool.uuid)
-            else:
-                LOG.info("Created machine pool %s", pool.uuid)
-            continue
-
-        LOG.info("Machine pool %s already exists, skipping", pool.uuid)
-
-
 def _ensure_exordos_config(spec: dict[str, tp.Any]):
     """Ensure gctl configuration file exists."""
     if "admin_password" not in spec:

exordos_core/compute/agents/universal/drivers/pool.py

@@ -46,7 +46,14 @@ class MetaPool(meta.MetaCoordinatorDataPlaneModel):
 
     __driver_map__ = {}
 
-    driver_spec = properties.property(types.Dict(), required=True)
+    driver_spec = properties.property(
+        types_dynamic.KindModelSelectorType(
+            types_dynamic.KindModelType(models.LibvirtPoolDriverSpec),
+            types_dynamic.KindModelType(models.ExordosLocalHyperDriverSpec),
+            types_dynamic.KindModelType(models.DummyPoolDriverSpec),
+        ),
+        required=True,
+    )
     machine_type = properties.property(
         types.Enum([t.value for t in nc.NodeType]),
         default=nc.NodeType.VM.value,
@@ -88,8 +95,7 @@ def load_driver(self) -> driver_base.AbstractPoolDriver:
         if driver_key in self.__driver_map__:
             return self.__driver_map__[driver_key]
 
-        # TODO(akremenetsky): Use dynamic typing for this field
-        driver_kind = self.driver_spec["driver"]
+        driver_kind = self.driver_spec.KIND
 
         class_ = utils.load_from_entry_point(nc.EP_MACHINE_POOL_DRIVERS, driver_kind)
 
@@ -816,3 +822,9 @@ class PoolAgentDriver(meta.MetaCoordinatorAgentDriver):
             },
         },
     }
+
+
+class LocalPoolAgentDriver(PoolAgentDriver):
+    def get_capabilities(self) -> list[str]:
+        """Returns a list of capabilities supported by the driver."""
+        return super().get_capabilities() + ["local_pool"]

exordos_core/compute/dm/models.py

@@ -102,6 +102,60 @@ def has_capacity(self, size: int) -> bool:
         return self.available >= size
 
 
+class AbstractPoolDriverSpec(
+    types_dynamic.AbstractKindModel,
+    models.SimpleViewMixin,
+):
+    """Base class for all pool driver specs."""
+
+
+class LibvirtPoolDriverSpec(AbstractPoolDriverSpec):
+    KIND = "libvirt"
+
+    connection_uri = properties.property(
+        types.String(max_length=2048),
+        required=True,
+    )
+    network = properties.property(
+        types.AllowNone(types.String(max_length=255)),
+        default=None,
+    )
+    storage_pool = properties.property(
+        types.AllowNone(types.String(max_length=255)),
+        default=None,
+    )
+    machine_prefix = properties.property(
+        types.AllowNone(types.String(max_length=255)),
+        default=None,
+    )
+    network_type = properties.property(
+        types.Enum(["network", "bridge"]),
+        default="network",
+    )
+    iface_rom_file = properties.property(
+        types.AllowNone(types.String(max_length=255)),
+        default=None,
+    )
+    iface_mtu = properties.property(
+        types.Integer(min_value=0, max_value=65536),
+        default=1500,
+    )
+    iface_source = properties.property(
+        types.AllowNone(types.String(max_length=255)),
+        default=None,
+    )
+
+
+class ExordosLocalHyperDriverSpec(LibvirtPoolDriverSpec):
+    KIND = "exordos_local_hyper"
+
+    node = properties.property(types.UUID(), required=True)
+
+
+class DummyPoolDriverSpec(AbstractPoolDriverSpec):
+    KIND = "dummy"
+
+
 class ThinStoragePool(
     AbstractStoragePool,
     models.ModelWithNameDesc,
@@ -146,7 +200,14 @@ class MachinePool(
     __tablename__ = "machine_pools"
     __driver_map__ = {}
 
-    driver_spec = properties.property(types.Dict(), default=dict)
+    driver_spec = properties.property(
+        types_dynamic.KindModelSelectorType(
+            types_dynamic.KindModelType(LibvirtPoolDriverSpec),
+            types_dynamic.KindModelType(ExordosLocalHyperDriverSpec),
+            types_dynamic.KindModelType(DummyPoolDriverSpec),
+        ),
+        required=True,
+    )
     agent = properties.property(types.AllowNone(types.UUID()), default=None)
     builder = properties.property(types.AllowNone(types.UUID()), default=None)
     machine_type = properties.property(
@@ -174,26 +235,6 @@ class MachinePool(
         default=list,
     )
 
-    @property
-    def has_driver(self) -> bool:
-        return bool(self.driver_spec)
-
-    @classmethod
-    def default_hw_pool(cls) -> tp.Optional["MachinePool"]:
-        """Get the default pool for HW machines if exists.
-
-        The method returns the default pool if only a pool
-        with required parameters exists and there are not
-        other pools with similar parameters.
-        """
-        return cls.objects.get_one_or_none(
-            filters={
-                "machine_type": dm_filters.EQ(nc.NodeType.HW.value),
-                "driver_spec": dm_filters.EQ("{}"),
-                "status": dm_filters.EQ(nc.MachinePoolStatus.ACTIVE.value),
-            },
-        )
-
     def load_driver(self) -> tp.Type["AbstractPoolDriver"]:
         """
         Load the driver for the machine pool.

exordos_core/compute/pool/drivers/base.py

@@ -143,16 +143,19 @@ def list_storage_pools(self) -> tp.Collection[models.AbstractStoragePool]:
 
 
 class DummyPoolDriver(AbstractPoolDriver):
-    SPEC = {"driver": "dummy"}
-
     def __init__(self, pool: models.MachinePool, dry_run: bool = False):
-        if pool.driver_spec != self.SPEC:
-            raise ValueError(f"Invalid driver spec: {pool.driver_spec}")
+        if pool.driver_spec is None or pool.driver_spec.KIND != "dummy":
+            raise ValueError(
+                f"Unsupported driver spec kind: "
+                f"{pool.driver_spec.KIND if pool.driver_spec else None!r}"
+            )
         super().__init__(dry_run=dry_run)
 
     def get_pool_info(self) -> models.MachinePool:
         """Get pool info."""
-        return models.MachinePool()
+        return models.MachinePool(
+            driver_spec=models.DummyPoolDriverSpec(),
+        )
 
     def list_pool_resources(
         self,
@@ -162,7 +165,13 @@ def list_pool_resources(
         tp.Collection[models.MachineVolume],
     ]:
         """List pool resources."""
-        return models.MachinePool(), [], []
+        return (
+            models.MachinePool(
+                driver_spec=models.DummyPoolDriverSpec(),
+            ),
+            [],
+            [],
+        )
 
     def list_machines(
         self,

exordos_core/compute/pool/drivers/libvirt.py

@@ -529,20 +529,16 @@ def add_interface(
         )
 
 
-class LibvirtPoolDriverSpec(tp.NamedTuple):
-    driver: tp.Literal["libvirt"]
-    network: str
-    storage_pool: str
-    connection_uri: str
-    machine_prefix: tp.Optional[str] = None
-    network_type: NetworkType = "network"
-    iface_rom_file: tp.Optional[str] = None
-    iface_mtu: int = 1450
-
-
 class LibvirtPoolDriver(base.AbstractPoolDriver):
     def __init__(self, pool: models.MachinePool, dry_run: bool = False):
-        self._spec = LibvirtPoolDriverSpec(**pool.driver_spec)
+        if pool.driver_spec is None or not isinstance(
+            pool.driver_spec, models.LibvirtPoolDriverSpec
+        ):
+            raise ValueError(
+                f"Unsupported driver spec kind: "
+                f"{pool.driver_spec.KIND if pool.driver_spec else None!r}"
+            )
+        self._spec = pool.driver_spec
         self._pool = pool
         # Check if connection string is valid and we can connect
         _ = self._client
@@ -860,6 +856,7 @@ def get_pool_info(self) -> models.MachinePool:
         """Get pool info."""
         info = self._client.getInfo()
         return models.MachinePool(
+            driver_spec=self._spec,
             all_cores=info[2],
             all_ram=info[1],
         )

exordos_core/compute/scheduler/service.py

@@ -159,7 +159,6 @@ def _get_pools(
                 "status": dm_filters.EQ(nc.MachinePoolStatus.ACTIVE.value),
                 "machine_type": dm_filters.EQ(nc.NodeType.VM.value),
                 "builder": dm_filters.IsNot(None),
-                "driver_spec": dm_filters.NE("{}"),
             },
             limit=limit,
         )
@@ -486,7 +485,33 @@ def _schedule_pools(self, pool_builders: tp.List[ua_models.UniversalAgent]) -> N
 
         for pool in unsheduled:
             builder = random.choice(pool_builders)
-            agent = random.choice(machine_agents[MACHINE_POOL_CAP])
+
+            # TODO(akremenetsky): In the target architecture, pool scheduling
+            # should be done through filters and weighters, similar to node
+            # scheduling. For now, use a simple condition for specific kinds.
+            # For exordos_local_hyper pools, only schedule on local agents
+            # whose node matches the pool's driver_spec.node.
+            # For other pools, exclude local agents (with local_pool capability)
+            # since they are dedicated to local hypervisors.
+            all_agents = machine_agents[MACHINE_POOL_CAP]
+            if pool.driver_spec.KIND == "exordos_local_hyper":
+                available_agents = [
+                    a for a in all_agents if a.node == pool.driver_spec.node
+                ]
+            else:
+                available_agents = [
+                    a for a in all_agents if "local_pool" not in a.list_capabilities
+                ]
+
+            if not available_agents:
+                LOG.warning(
+                    "No suitable agents found to schedule pool %s (kind=%s)",
+                    pool.uuid,
+                    pool.driver_spec.KIND,
+                )
+                continue
+
+            agent = random.choice(available_agents)
 
             try:
                 pool.builder = builder.uuid

exordos_core/tests/functional/conftest.py

@@ -559,7 +559,11 @@ def factory(
         **kwargs,
     ) -> tp.Dict[str, tp.Any]:
         uuid = uuid or _make_uuid()
-        driver_spec = {"driver": "libvirt"} if driver_spec is None else driver_spec
+        driver_spec = (
+            {"kind": "libvirt", "connection_uri": "qemu+tcp://127.0.0.1/system"}
+            if driver_spec is None
+            else driver_spec
+        )
         status_value = nc.MachinePoolStatus.ACTIVE.value if status is None else status
         storage_pool = node_models.ThinStoragePool(
             pool_type="dummy",
@@ -569,17 +573,17 @@ def factory(
             available_actual=1000,
         )
 
-        pool = node_models.MachinePool(
-            uuid=uuid,
-            agent=agent,
+        pool = node_models.MachinePool.restore_from_simple_view(
+            uuid=str(uuid),
+            agent=str(agent) if agent else None,
             name=name,
             status=status_value,
             driver_spec=driver_spec,
             avail_cores=avail_cores,
             avail_ram=avail_ram,
             all_cores=all_cores,
             all_ram=all_ram,
-            storage_pools=[storage_pool],
+            storage_pools=[storage_pool.dump_to_simple_view()],
             **kwargs,
         )
         view = pool.dump_to_simple_view()