vars: make interface more type-safe

pkgs/clan-cli/clan_cli/vars/check.py

@@ -1,75 +1,91 @@
 import argparse
 import importlib
 import logging
-from dataclasses import dataclass
 
 from clan_cli.completions import add_dynamic_completer, complete_machines
+from clan_cli.errors import ClanError
 from clan_cli.machines.machines import Machine
+from clan_cli.vars.public_modules import FactStoreBase
+from clan_cli.vars.secret_modules import SecretStoreBase
 
 log = logging.getLogger(__name__)
 
+from typing import TYPE_CHECKING
 
-@dataclass
-class Var:
-    generator: str
-    name: str
+if TYPE_CHECKING:
+    from .generate import Var
 
 
-@dataclass
 class VarStatus:
-    missing_secret_vars: list[Var]
-    missing_public_vars: list[Var]
-    unfixed_secret_vars: list[Var]
-    invalid_generators: list[str]
+    def __init__(
+        self,
+        missing_secret_vars: list["Var"],
+        missing_public_vars: list["Var"],
+        unfixed_secret_vars: list["Var"],
+        invalid_generators: list[str],
+    ) -> None:
+        self.missing_secret_vars = missing_secret_vars
+        self.missing_public_vars = missing_public_vars
+        self.unfixed_secret_vars = unfixed_secret_vars
+        self.invalid_generators = invalid_generators
 
 
 def vars_status(machine: Machine, generator_name: None | str = None) -> VarStatus:
     secret_vars_module = importlib.import_module(machine.secret_vars_module)
-    secret_vars_store = secret_vars_module.SecretStore(machine=machine)
+    secret_vars_store: SecretStoreBase = secret_vars_module.SecretStore(machine=machine)
     public_vars_module = importlib.import_module(machine.public_vars_module)
-    public_vars_store = public_vars_module.FactStore(machine=machine)
+    public_vars_store: FactStoreBase = public_vars_module.FactStore(machine=machine)
 
     missing_secret_vars = []
     missing_public_vars = []
     # signals if a var needs to be updated (eg. needs re-encryption due to new users added)
     unfixed_secret_vars = []
     invalid_generators = []
+    generators = machine.vars_generators
     if generator_name:
-        generators = [generator_name]
-    else:
-        generators = list(machine.vars_generators.keys())
-    for generator_name in generators:
-        shared = machine.vars_generators[generator_name]["share"]
-        for name, file in machine.vars_generators[generator_name]["files"].items():
-            if file["secret"]:
-                if not secret_vars_store.exists(generator_name, name, shared=shared):
+        for generator in generators:
+            if generator_name == generator.name:
+                generators = [generator]
+                break
+        else:
+            err_msg = (
+                f"Generator '{generator_name}' not found in machine {machine.name}"
+            )
+            raise ClanError(err_msg)
+
+    for generator in generators:
+        generator.machine(machine)
+        for file in generator.files:
+            file.store(secret_vars_store if file.secret else public_vars_store)
+            file.generator(generator)
+
+            if file.secret:
+                if not secret_vars_store.exists(generator, file.name):
                     log.info(
-                        f"Secret var '{name}' for service '{generator_name}' in machine {machine.name} is missing."
+                        f"Secret var '{file.name}' for service '{generator.name}' in machine {machine.name} is missing."
                     )
-                    missing_secret_vars.append(Var(generator_name, name))
+                    missing_secret_vars.append(file)
                 else:
-                    needs_fix, msg = secret_vars_store.needs_fix(
-                        generator_name, name, shared=shared
-                    )
+                    needs_fix, msg = secret_vars_store.needs_fix(generator, file.name)
                     if needs_fix:
                         log.info(
-                            f"Secret var '{name}' for service '{generator_name}' in machine {machine.name} needs update: {msg}"
+                            f"Secret var '{file.name}' for service '{generator.name}' in machine {machine.name} needs update: {msg}"
                         )
-                        unfixed_secret_vars.append(Var(generator_name, name))
+                        unfixed_secret_vars.append(file)
 
-            elif not public_vars_store.exists(generator_name, name, shared=shared):
+            elif not public_vars_store.exists(generator, file.name):
                 log.info(
-                    f"Public var '{name}' for service '{generator_name}' in machine {machine.name} is missing."
+                    f"Public var '{file.name}' for service '{generator.name}' in machine {machine.name} is missing."
                 )
-                missing_public_vars.append(Var(generator_name, name))
+                missing_public_vars.append(file)
         # check if invalidation hash is up to date
         if not (
-            secret_vars_store.hash_is_valid(generator_name)
-            and public_vars_store.hash_is_valid(generator_name)
+            secret_vars_store.hash_is_valid(generator)
+            and public_vars_store.hash_is_valid(generator)
         ):
-            invalid_generators.append(generator_name)
+            invalid_generators.append(generator.name)
             log.info(
-                f"Generator '{generator_name}' in machine {machine.name} has outdated invalidation hash."
+                f"Generator '{generator.name}' in machine {machine.name} has outdated invalidation hash."
             )
     log.debug(f"missing_secret_vars: {missing_secret_vars}")
     log.debug(f"missing_public_vars: {missing_public_vars}")