cluster-builder 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

cluster_builder/config/cluster.py

@@ -4,7 +4,8 @@ Cluster configuration management.
 
 import os
 import logging
-
+import secrets
+import string
 from names_generator import generate_name
 
 from cluster_builder.infrastructure import TemplateManager
@@ -50,9 +51,25 @@ class ClusterConfig:
             A randomly generated name
         """
         name = generate_name()
+        name = name.replace("_", "-")
         logger.debug(f"Generated random name: {name}")
         return name
 
+    def generate_k3s_token(self, length: int = 16) -> str:
+        """
+        Generate a secure random alphanumeric token for K3s.
+
+        Args:
+            length: Length of the token (default: 16)
+
+        Returns:
+            A secure, randomly generated alphanumeric token
+        """
+        chars = string.ascii_letters + string.digits
+        token = ''.join(secrets.choice(chars) for _ in range(length))
+        logger.debug(f"Generated K3s token: {token}")
+        return token
+
     def prepare(self, config: dict[str, any]) -> tuple[str, dict[str, any]]:
         """
         Prepare the configuration and template files for deployment.
@@ -84,7 +101,7 @@ class ClusterConfig:
 
         cloud = prepared_config["cloud"]
         role = prepared_config["k3s_role"]
-        logger.info(f"Preparing configuration for cloud={cloud}, role={role}")
+        logger.debug(f"Preparing configuration for cloud={cloud}, role={role}")
 
         # Set module source path
         prepared_config["module_source"] = self.template_manager.get_module_source_path(
@@ -92,14 +109,22 @@ class ClusterConfig:
         )
         logger.debug(f"Using module source: {prepared_config['module_source']}")
 
+        # create k3s-token if not provided
+        if "k3s_token" not in prepared_config:
+            logger.debug("Generating k3s token for cluster")
+            k3s_token = self.generate_k3s_token()
+            prepared_config["k3s_token"] = k3s_token
+        else:
+            logger.debug(f"Using provided K3s token: {prepared_config['k3s_token']}")
+
         # Generate a cluster name if not provided
         if "cluster_name" not in prepared_config:
             cluster_name = self.generate_random_name()
             prepared_config["cluster_name"] = cluster_name
-            logger.info(f"Generated cluster name: {cluster_name}")
+            logger.info(f"Creating new cluster: {cluster_name}")
         else:
             logger.info(
-                f"Using provided cluster name: {prepared_config['cluster_name']}"
+                f"Adding node to existing cluster: {prepared_config['cluster_name']}"
             )
 
         cluster_dir = self.get_cluster_output_dir(prepared_config["cluster_name"])
@@ -107,7 +132,7 @@ class ClusterConfig:
 
         # Generate a resource name
         random_name = self.generate_random_name()
-        prepared_config["resource_name"] = f"{cloud}_{random_name}"
+        prepared_config["resource_name"] = f"{cloud}-{random_name}"
         logger.debug(f"Resource name: {prepared_config['resource_name']}")
 
         # Create the cluster directory

cluster_builder/config/postgres.py

@@ -37,10 +37,12 @@ class PostgresConfig:
         missing_keys = [key for key in required_keys if key not in config]
 
         if missing_keys:
+            logger.error(f"Missing required PostgreSQL configuration keys: {', '.join(missing_keys)}")
             raise ValueError(
                 f"Missing required PostgreSQL configuration: {', '.join(missing_keys)}"
             )
 
+        logger.info(f"Creating PostgresConfig from dict with user={config.get('user')} host={config.get('host')} database={config.get('database')}")
         return cls(
             user=config["user"],
             password=config["password"],
@@ -77,11 +79,12 @@ class PostgresConfig:
         missing_vars = [var for var in required_vars if not os.environ.get(var)]
 
         if missing_vars:
+            logger.error(f"Missing required PostgreSQL environment variables: {', '.join(missing_vars)}")
             raise ValueError(
                 f"Missing required PostgreSQL environment variables: {', '.join(missing_vars)}"
             )
 
-        # Create config from environment variables
+        logger.info(f"Creating PostgresConfig from environment with user={os.environ.get('POSTGRES_USER')} host={os.environ.get('POSTGRES_HOST')} database={os.environ.get('POSTGRES_DATABASE')}")
         return cls(
             user=os.environ["POSTGRES_USER"],
             password=os.environ["POSTGRES_PASSWORD"],

cluster_builder/infrastructure/executor.py

@@ -5,6 +5,9 @@ Command execution utilities for infrastructure management.
 import subprocess
 import logging
 
+from yaspin import yaspin
+from yaspin.spinners import Spinners
+
 logger = logging.getLogger("swarmchestrate")
 
 
@@ -13,7 +16,11 @@ class CommandExecutor:
 
     @staticmethod
     def run_command(
-        command: list, cwd: str, description: str = "command", timeout: int = None
+        command: list,
+        cwd: str,
+        description: str = "command",
+        timeout: int = None,
+        env: dict = None,  # <-- Add optional env param
     ) -> str:
         """
         Execute a shell command with proper logging and error handling.
@@ -33,56 +40,49 @@ class CommandExecutor:
         cmd_str = " ".join(command)
         logger.info(f"Running {description}: {cmd_str}")
 
-        try:
-            # Start the process using Popen
-            process = subprocess.Popen(
-                command,
-                cwd=cwd,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-            )
-
-            # Wait for the process with timeout
+        show_spinner = timeout is None or timeout > 15
+
+        process = subprocess.Popen(
+            command,
+            cwd=cwd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            env=env,
+        )
+
+        if show_spinner:
             try:
-                stdout, stderr = process.communicate(timeout=timeout)
+                process.wait(timeout=15)
+                stdout, stderr = process.communicate()
+                return CommandExecutor._check_result(stdout, stderr, process.returncode, description)
+            except subprocess.TimeoutExpired:
+                pass  # Still running → spinner starts
 
-                # Check if the process was successful
-                if process.returncode != 0:
-                    error_msg = f"Error executing {description}: {stderr}"
-                    logger.error(error_msg)
-                    raise RuntimeError(error_msg)
+        # Either timeout <= 15s, or process still running after 15s
+        spinner = yaspin(Spinners.point, text=f"Running {description}...", color="cyan") if show_spinner else None
+        if spinner:
+            spinner.start()
 
-                logger.debug(f"{description.capitalize()} output: {stdout}")
-                return stdout
+        try:
+            stdout, stderr = process.communicate(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            stdout, stderr = process.communicate()
+            if spinner:
+                spinner.fail("⏰")
+            raise RuntimeError(f"{description.capitalize()} timed out after {timeout} seconds")
 
-            except subprocess.TimeoutExpired:
-                # Process timed out - try to get any output so far
-                # Kill the process
-                process.kill()
+        if spinner:
+            spinner.ok("✅") if process.returncode == 0 else spinner.fail("💥")
 
-                # Capture any output that was generated before the timeout
-                stdout, stderr = process.communicate()
+        return CommandExecutor._check_result(stdout, stderr, process.returncode, description)
 
-                # Print and log the captured output
-                print(f"\n--- {description.capitalize()} stdout before timeout ---")
-                print(stdout)
-                print(f"\n--- {description.capitalize()} stderr before timeout ---")
-                print(stderr)
-
-                error_msg = (
-                    f"{description.capitalize()} timed out after {timeout} seconds"
-                )
-                logger.error(error_msg)
-                raise RuntimeError(error_msg) from None
-
-        except subprocess.CalledProcessError as e:
-            error_msg = f"Error executing {description}: {e.stderr}"
-            logger.error(error_msg)
-            raise RuntimeError(error_msg)
-        except Exception as e:
-            if not isinstance(e, RuntimeError):  # Avoid re-wrapping our own exceptions
-                error_msg = f"Unexpected error during {description}: {str(e)}"
-                logger.error(error_msg)
-                raise RuntimeError(error_msg)
-            raise
+    @staticmethod
+    def _check_result(stdout, stderr, returncode, description):
+        if returncode != 0:
+            err = f"Error executing {description}: {stderr}"
+            logger.error(err)
+            raise RuntimeError(err)
+        logger.debug(f"{description.capitalize()} output: {stdout}")
+        return stdout

cluster_builder/infrastructure/templates.py

@@ -65,7 +65,7 @@ class TemplateManager:
         try:
             # Simply copy the provider config file to the cluster directory
             shutil.copy2(provider_template_path, provider_file)
-            logger.info(f"Created {cloud} provider configuration at {provider_file}")
+            logger.debug(f"Created {cloud} provider configuration at {provider_file}")
         except Exception as e:
             error_msg = f"Failed to create provider configuration: {e}"
             logger.error(error_msg)
@@ -94,7 +94,7 @@ class TemplateManager:
 
         try:
             shutil.copy2(user_data_src, user_data_dst)
-            logger.info(
+            logger.debug(
                 f"Copied user data template from {user_data_src} to {user_data_dst}"
             )
         except (OSError, shutil.Error) as e: