cluster-builder 0.1.1__tar.gz → 0.2.0__tar.gz

{cluster_builder-0.1.1 → cluster_builder-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cluster-builder
-Version: 0.1.1
+Version: 0.2.0
 Summary: Swarmchestrate cluster builder
 Author-email: Gunjan <G.Kotak@westminster.ac.uk>, Jay <J.Deslauriers@westminster.ac.uk>
 License: Apache2

cluster_builder-0.2.0/cluster_builder/config/__init__.py

@@ -0,0 +1,8 @@
+"""
+Configuration management for the Cluster Builder.
+"""
+
+from cluster_builder.config.postgres import PostgresConfig
+from cluster_builder.config.cluster import ClusterConfig
+
+__all__ = ["PostgresConfig", "ClusterConfig"]

cluster_builder-0.2.0/cluster_builder/config/cluster.py

@@ -0,0 +1,125 @@
+"""
+Cluster configuration management.
+"""
+
+import os
+import logging
+
+from names_generator import generate_name
+
+from cluster_builder.templates.manager import TemplateManager
+
+logger = logging.getLogger("swarmchestrate")
+
+
+class ClusterConfig:
+    """Manages cluster configuration and preparation."""
+
+    def __init__(
+        self,
+        template_manager: TemplateManager,
+        output_dir: str,
+    ):
+        """
+        Initialise the ClusterConfig.
+
+        Args:
+            template_manager: Template manager instance
+            output_dir: Directory for output files
+        """
+        self.template_manager = template_manager
+        self.output_dir = output_dir
+
+    def get_cluster_output_dir(self, cluster_name: str) -> str:
+        """
+        Get the output directory path for a specific cluster.
+
+        Args:
+            cluster_name: Name of the cluster
+
+        Returns:
+            Path to the cluster output directory
+        """
+        return os.path.join(self.output_dir, f"cluster_{cluster_name}")
+
+    def generate_random_name(self) -> str:
+        """
+        Generate a readable random string using names-generator.
+
+        Returns:
+            A randomly generated name
+        """
+        name = generate_name()
+        logger.debug(f"Generated random name: {name}")
+        return name
+
+    def prepare(self, config: dict[str, any]) -> tuple[str, dict[str, any]]:
+        """
+        Prepare the configuration and template files for deployment.
+
+        Args:
+            config: Configuration dictionary containing cloud, k3s_role, and
+                   optionally cluster_name
+
+        Returns:
+            Tuple containing the cluster directory path and updated configuration
+
+        Raises:
+            ValueError: If required configuration is missing
+            RuntimeError: If file operations fail
+        """
+        # Validate required configuration
+        if "cloud" not in config:
+            error_msg = "Cloud provider must be specified in configuration"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        if "k3s_role" not in config:
+            error_msg = "K3s role must be specified in configuration"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        # Create a copy of the configuration
+        prepared_config = config.copy()
+
+        cloud = prepared_config["cloud"]
+        role = prepared_config["k3s_role"]
+        logger.info(f"Preparing configuration for cloud={cloud}, role={role}")
+
+        # Set module source path
+        prepared_config["module_source"] = self.template_manager.get_module_source_path(
+            cloud
+        )
+        logger.debug(f"Using module source: {prepared_config['module_source']}")
+
+        # 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}")
+        else:
+            logger.info(
+                f"Using provided cluster name: {prepared_config['cluster_name']}"
+            )
+
+        cluster_dir = self.get_cluster_output_dir(prepared_config["cluster_name"])
+        logger.debug(f"Cluster directory: {cluster_dir}")
+
+        # Generate a resource name
+        random_name = self.generate_random_name()
+        prepared_config["resource_name"] = f"{cloud}_{random_name}"
+        logger.debug(f"Resource name: {prepared_config['resource_name']}")
+
+        # Create the cluster directory
+        try:
+            os.makedirs(cluster_dir, exist_ok=True)
+            logger.debug(f"Created directory: {cluster_dir}")
+        except OSError as e:
+            error_msg = f"Failed to create directory {cluster_dir}: {e}"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+
+        # Copy user data template
+        self.template_manager.copy_user_data_template(role, cloud)
+
+        return cluster_dir, prepared_config

cluster_builder-0.2.0/cluster_builder/config/postgres.py

@@ -0,0 +1,99 @@
+"""
+PostgreSQL configuration for Terraform state backend.
+"""
+
+import os
+import logging
+from dataclasses import dataclass
+
+logger = logging.getLogger("swarmchestrate")
+
+
+@dataclass
+class PostgresConfig:
+    """Configuration for PostgreSQL backend."""
+
+    user: str
+    password: str
+    host: str
+    database: str
+    sslmode: str = "prefer"
+
+    @classmethod
+    def from_dict(cls, config: dict[str, str]) -> "PostgresConfig":
+        """
+        Create a PostgresConfig instance from a dictionary.
+
+        Args:
+            config: Dictionary containing PostgreSQL configuration
+
+        Returns:
+            PostgresConfig instance
+
+        Raises:
+            ValueError: If required configuration is missing
+        """
+        required_keys = ["user", "password", "host", "database"]
+        missing_keys = [key for key in required_keys if key not in config]
+
+        if missing_keys:
+            raise ValueError(
+                f"Missing required PostgreSQL configuration: {', '.join(missing_keys)}"
+            )
+
+        return cls(
+            user=config["user"],
+            password=config["password"],
+            host=config["host"],
+            database=config["database"],
+            sslmode=config.get("sslmode", "prefer"),
+        )
+
+    @classmethod
+    def from_env(cls) -> "PostgresConfig":
+        """
+        Create a PostgresConfig instance from environment variables.
+
+        Environment variables used:
+        - POSTGRES_USER
+        - POSTGRES_PASSWORD
+        - POSTGRES_HOST
+        - POSTGRES_DATABASE
+        - POSTGRES_SSLMODE (optional, defaults to 'prefer')
+
+        Returns:
+            PostgresConfig instance
+
+        Raises:
+            ValueError: If required environment variables are missing
+        """
+        # Check for required environment variables
+        required_vars = [
+            "POSTGRES_USER",
+            "POSTGRES_PASSWORD",
+            "POSTGRES_HOST",
+            "POSTGRES_DATABASE",
+        ]
+        missing_vars = [var for var in required_vars if not os.environ.get(var)]
+
+        if missing_vars:
+            raise ValueError(
+                f"Missing required PostgreSQL environment variables: {', '.join(missing_vars)}"
+            )
+
+        # Create config from environment variables
+        return cls(
+            user=os.environ["POSTGRES_USER"],
+            password=os.environ["POSTGRES_PASSWORD"],
+            host=os.environ["POSTGRES_HOST"],
+            database=os.environ["POSTGRES_DATABASE"],
+            sslmode=os.environ.get("POSTGRES_SSLMODE", "prefer"),
+        )
+
+    def get_connection_string(self) -> str:
+        """Generate a PostgreSQL connection string from the configuration."""
+        return (
+            f"postgres://{self.user}:{self.password}@"
+            f"{self.host}:5432/{self.database}?"
+            f"sslmode={self.sslmode}"
+        )

cluster_builder-0.2.0/cluster_builder/infrastructure/__init__.py

@@ -0,0 +1,7 @@
+"""
+Infrastructure management for the Cluster Builder.
+"""
+
+from cluster_builder.infrastructure.executor import CommandExecutor
+
+__all__ = ["CommandExecutor"]

cluster_builder-0.2.0/cluster_builder/infrastructure/executor.py

@@ -0,0 +1,88 @@
+"""
+Command execution utilities for infrastructure management.
+"""
+
+import subprocess
+import logging
+
+logger = logging.getLogger("swarmchestrate")
+
+
+class CommandExecutor:
+    """Utility for executing shell commands with proper logging and error handling."""
+
+    @staticmethod
+    def run_command(
+        command: list, cwd: str, description: str = "command", timeout: int = None
+    ) -> str:
+        """
+        Execute a shell command with proper logging and error handling.
+
+        Args:
+            command: List containing the command and its arguments
+            cwd: Working directory for the command
+            description: Description of the command for logging
+            timeout: Maximum execution time in seconds (None for no timeout)
+
+        Returns:
+            Command stdout output as string
+
+        Raises:
+            RuntimeError: If the command execution fails or times out
+        """
+        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
+            try:
+                stdout, stderr = process.communicate(timeout=timeout)
+
+                # 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)
+
+                logger.debug(f"{description.capitalize()} output: {stdout}")
+                return stdout
+
+            except subprocess.TimeoutExpired:
+                # Process timed out - try to get any output so far
+                # Kill the process
+                process.kill()
+
+                # Capture any output that was generated before the timeout
+                stdout, stderr = process.communicate()
+
+                # 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

{cluster_builder-0.1.1 → cluster_builder-0.2.0}/cluster_builder/swarmchestrate.py

@@ -50,9 +50,7 @@ class Swarmchestrate:
 
         # Initialise components
         self.template_manager = TemplateManager()
-        self.cluster_config = ClusterConfig(
-            self.template_manager, output_dir, self.pg_config
-        )
+        self.cluster_config = ClusterConfig(self.template_manager, output_dir)
 
         logger.info(
             f"Initialised with template_dir={template_dir}, output_dir={output_dir}"
@@ -79,23 +77,17 @@ class Swarmchestrate:
         """
         return self.cluster_config.generate_random_name()
 
-    def _validate_node_config(self, config: dict[str, any]) -> None:
+    def validate_configuration(self, cloud: str, config: dict) -> list:
         """
-        Validate node configuration.
+        Validate a configuration against the required variables for a cloud provider.
 
         Args:
-            config: Configuration dictionary
+            cloud: Cloud provider name
+            config: Configuration dictionary provided by the user
 
-        Raises:
-            ValueError: If configuration is invalid
+        Returns:
+            List of missing required variables (empty if all required variables are present)
         """
-        # Check required fields
-        if "cloud" not in config:
-            raise ValueError("Cloud provider must be specified in configuration")
-
-        if "k3s_role" not in config:
-            raise ValueError("K3s role must be specified in configuration")
-
         # Master IP validation
         has_master_ip = "master_ip" in config and config["master_ip"]
         role = config["k3s_role"]
@@ -103,13 +95,24 @@ class Swarmchestrate:
         # Cannot add a master node to an existing cluster
         if has_master_ip and role == "master":
             raise ValueError(
-                "Cannot add a master node to an existing cluster (master_ip specified with master role)"
+                "Cannot add master to existing cluster (master_ip specified with master role)"
             )
 
         # Worker/HA nodes require a master IP
         if not has_master_ip and role in ["worker", "ha"]:
             raise ValueError(f"Role '{role}' requires master_ip to be specified")
 
+        required_vars = self.template_manager.get_required_variables(cloud)
+
+        # Find missing required variables
+        missing_vars = []
+        for var_name, var_config in required_vars.items():
+            # If variable has no default and is not in config, it's required but missing
+            if "default" not in var_config and var_name not in config:
+                missing_vars.append(var_name)
+
+        return missing_vars
+
     def prepare_infrastructure(
         self, config: dict[str, any]
     ) -> tuple[str, dict[str, any]]:
@@ -131,14 +134,18 @@ class Swarmchestrate:
             RuntimeError: If file operations fail
         """
         try:
-            # Validate the configuration
-            self._validate_node_config(config)
-
-            # Prepare the configuration and files
+            # Prepare the configuration
             cluster_dir, prepared_config = self.cluster_config.prepare(config)
 
+            # Validate the configuration
+            cloud = prepared_config["cloud"]
+            missing_vars = self.validate_configuration(cloud, prepared_config)
+            if missing_vars:
+                raise ValueError(
+                    f"Missing required variables for cloud provider '{cloud}': {', '.join(missing_vars)}"
+                )
+
             # Create provider configuration
-            cloud = config["cloud"]
             self.template_manager.create_provider_config(cluster_dir, cloud)
             logger.info(f"Created provider configuration for {cloud}")
 
@@ -147,9 +154,12 @@ class Swarmchestrate:
             backend_tf_path = os.path.join(cluster_dir, "backend.tf")
 
             # Add backend configuration
+
+            # Add PostgreSQL connection string to config
+            conn_str = self.pg_config.get_connection_string()
             hcl.add_backend_config(
                 backend_tf_path,
-                prepared_config["pg_conn_str"],
+                conn_str,
                 prepared_config["cluster_name"],
             )
             logger.info(f"Added backend configuration to {backend_tf_path}")
@@ -294,7 +304,12 @@ class Swarmchestrate:
                 return
 
             # Plan the deployment
-            CommandExecutor.run_command(["tofu", "plan"], cluster_dir, "OpenTofu plan")
+            CommandExecutor.run_command(
+                ["tofu", "plan", "-input=false"],
+                cluster_dir,
+                "OpenTofu plan",
+                timeout=30,
+            )
 
             # Apply the deployment
             CommandExecutor.run_command(
@@ -335,7 +350,10 @@ class Swarmchestrate:
         try:
             # Plan destruction
             CommandExecutor.run_command(
-                ["tofu", "plan", "-destroy"], cluster_dir, "OpenTofu plan destruction"
+                ["tofu", "plan", "-destroy", "-input=false"],
+                cluster_dir,
+                "OpenTofu plan destruction",
+                timeout=30,
             )
 
             # Execute destruction

cluster_builder-0.2.0/cluster_builder/templates/__init__.py

@@ -0,0 +1,7 @@
+"""
+Template management for the Cluster Builder.
+"""
+
+from cluster_builder.templates.manager import TemplateManager
+
+__all__ = ["TemplateManager"]

cluster_builder-0.2.0/cluster_builder/templates/manager.py

@@ -0,0 +1,118 @@
+"""
+Template management for cluster deployments.
+"""
+
+import os
+import shutil
+import logging
+
+from cluster_builder.utils.hcl import extract_template_variables
+
+logger = logging.getLogger("swarmchestrate")
+
+
+class TemplateManager:
+    """Manages template files and operations for cluster deployment."""
+
+    def __init__(self):
+        """Initialise the TemplateManager."""
+        current_dir = os.path.dirname(os.path.abspath(__file__))  # templates directory
+        self.base_dir = os.path.dirname(
+            os.path.dirname(current_dir)
+        )  # Go up two levels
+        self.templates_dir = os.path.join(self.base_dir, "templates")
+        logger.debug(
+            f"Initialised TemplateManager with templates_dir={self.templates_dir}"
+        )
+
+    def get_module_source_path(self, cloud: str) -> str:
+        """
+        Get the module source path for a specific cloud provider.
+
+        Args:
+            cloud: Cloud provider name
+
+        Returns:
+            Path to the module source directory
+        """
+        return f"{self.templates_dir}/{cloud}/"
+
+    def create_provider_config(self, cluster_dir: str, cloud: str) -> None:
+        """
+        Create provider configuration file for a specific cloud provider.
+
+        Args:
+            cluster_dir: Directory for the cluster
+            cloud: Cloud provider (e.g., 'aws')
+
+        Raises:
+            ValueError: If provider template is not found
+        """
+        # Define the path for provider config in templates directory
+        provider_template_path = os.path.join(
+            self.templates_dir, f"{cloud.lower()}_provider.tf"
+        )
+
+        # Check if template exists
+        if not os.path.exists(provider_template_path):
+            error_msg = f"Provider template not found: {provider_template_path}"
+            logger.error(error_msg)
+            raise ValueError(
+                f"Provider template for cloud '{cloud}' not found. Expected at: {provider_template_path}"
+            )
+
+        # Target file in cluster directory
+        provider_file = os.path.join(cluster_dir, f"{cloud.lower()}_provider.tf")
+
+        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}")
+        except Exception as e:
+            error_msg = f"Failed to create provider configuration: {e}"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+
+    def copy_user_data_template(self, role: str, cloud: str) -> None:
+        """
+        Copy the user data template for a specific role to the cloud provider directory.
+
+        Args:
+            role: K3s role (master, worker, etc.)
+            cloud: Cloud provider name
+
+        Raises:
+            RuntimeError: If the template file doesn't exist or can't be copied
+        """
+        user_data_src = os.path.join(self.templates_dir, f"{role}_user_data.sh.tpl")
+        user_data_dst = os.path.join(
+            self.templates_dir, cloud, f"{role}_user_data.sh.tpl"
+        )
+
+        if not os.path.exists(user_data_src):
+            error_msg = f"User data template not found: {user_data_src}"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+
+        try:
+            shutil.copy2(user_data_src, user_data_dst)
+            logger.info(
+                f"Copied user data template from {user_data_src} to {user_data_dst}"
+            )
+        except (OSError, shutil.Error) as e:
+            error_msg = f"Failed to copy user data template: {e}"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+
+    def get_required_variables(self, cloud: str) -> dict:
+        """
+        Get the variables required for a specific cloud provider's templates.
+
+        Args:
+            cloud: Cloud provider name (e.g., 'aws')
+
+        Returns:
+            Dictionary of variable names to their configurations
+        """
+        template_path = os.path.join(self.templates_dir, cloud, "main.tf")
+        return extract_template_variables(template_path)

cluster_builder-0.2.0/cluster_builder/utils/__init__.py

@@ -0,0 +1,7 @@
+"""
+Utility functions for the Cluster Builder.
+"""
+
+from cluster_builder.utils.logging import configure_logging
+
+__all__ = ["configure_logging"]

cluster_builder-0.2.0/cluster_builder/utils/hcl.py

@@ -0,0 +1,231 @@
+import os
+import hcl2
+from lark import Tree, Token
+
+
+def add_backend_config(backend_tf_path, conn_str, schema_name):
+    """
+    Adds a PostgreSQL backend configuration to a Terraform file.
+    - `backend_tf_path`: path to backend.tf for this configuration
+    - `conn_str`: PostgreSQL connection string
+    - `schema_name`: Schema name for Terraform state
+    """
+    # Check if the backend configuration already exists
+    if os.path.exists(backend_tf_path):
+        with open(backend_tf_path) as f:
+            if 'backend "pg"' in f.read():
+                print("⚠️  Backend configuration already exists — skipping.")
+                return
+
+    # Build the backend configuration block
+    lines = [
+        "terraform {",
+        '  backend "pg" {',
+        f'    conn_str = "{conn_str}"',
+        f'    schema_name = "{schema_name}"',
+        "  }",
+        "}",
+    ]
+
+    # Write to backend.tf
+    os.makedirs(os.path.dirname(backend_tf_path), exist_ok=True)
+    with open(
+        backend_tf_path, "w"
+    ) as f:  # Use "w" instead of "a" to create/overwrite the file
+        f.write("\n".join(lines) + "\n")
+
+    print(f"✅ Added PostgreSQL backend configuration to {backend_tf_path}")
+
+
+def add_module_block(main_tf_path, module_name, config):
+    """
+    Appends a new module block to main.tf for this RA+cluster.
+    - `main_tf_path`: path to `main.tf` for this RA+cluster
+    - `module_name`: e.g. "master_xyz123"
+    - `config`: dict of configuration and module-specific variables
+    """
+    # Check if the module already exists
+    if os.path.exists(main_tf_path):
+        with open(main_tf_path) as f:
+            if f'module "{module_name}"' in f.read():
+                print(f"⚠️  Module '{module_name}' already exists — skipping.")
+                return
+
+    # Build the module block
+    lines = [f'module "{module_name}" {{', f'  source = "{config["module_source"]}"']
+    for k, v in config.items():
+        if k == "module_source":
+            continue  # Skip the module source since it's already handled
+        if isinstance(v, bool):
+            v_str = "true" if v else "false"
+        elif isinstance(v, (int, float)):
+            v_str = str(v)
+        elif v is None:
+            continue
+        else:
+            v_str = f'"{v}"'
+        lines.append(f"  {k} = {v_str}")
+    lines.append("}")
+
+    # Write to main.tf
+    with open(main_tf_path, "a") as f:
+        f.write("\n\n" + "\n".join(lines) + "\n")
+
+    print(f"✅ Added module '{module_name}' to {main_tf_path}")
+
+
+def is_target_module_block(tree: Tree, module_name: str) -> bool:
+    """
+    Check if the tree is a module block with the specified name.
+    """
+    if tree.data != "block":
+        return False
+
+    # Need at least 3 children: identifier, name, body
+    if len(tree.children) < 3:
+        return False
+
+    # First child should be an identifier tree
+    first_child = tree.children[0]
+    if not isinstance(first_child, Tree) or first_child.data != "identifier":
+        return False
+
+    # First child should have a NAME token with 'module'
+    if len(first_child.children) == 0 or not isinstance(first_child.children[0], Token):
+        return False
+
+    if first_child.children[0].value != "module":
+        return False
+
+    # Second child should be a STRING_LIT token with module name
+    second_child = tree.children[1]
+    if not isinstance(second_child, Token) or second_child.value != f'"{module_name}"':
+        return False
+
+    return True
+
+
+def simple_remove_module(tree, module_name, removed=False):
+    """
+    A simpler function to remove module blocks that maintains the exact Tree structure
+    that the write function expects.
+    """
+    # Don't remove the root node
+    if tree.data == "start":
+        # Process only the body of the start rule
+        body_node = tree.children[0]
+
+        if isinstance(body_node, Tree) and body_node.data == "body":
+            # Create new children list for the body node
+            new_body_children = []
+            skip_next = False
+
+            # Process body children (these should be blocks and new_line_or_comment nodes)
+            for i, child in enumerate(body_node.children):
+                if skip_next:
+                    skip_next = False
+                    continue
+
+                # If this is a block node, check if it's our target
+                if (
+                    isinstance(child, Tree)
+                    and child.data == "block"
+                    and is_target_module_block(child, module_name)
+                ):
+                    removed = True
+
+                    # Check if the next node is a new_line_or_comment, and skip it as well
+                    if i + 1 < len(body_node.children):
+                        next_child = body_node.children[i + 1]
+                        if (
+                            isinstance(next_child, Tree)
+                            and next_child.data == "new_line_or_comment"
+                        ):
+                            skip_next = True
+                else:
+                    new_body_children.append(child)
+
+            # Replace body children with filtered list
+            new_body = Tree(body_node.data, new_body_children)
+            return Tree(tree.data, [new_body]), removed
+
+    # No changes made
+    return tree, removed
+
+
+def remove_module_block(main_tf_path, module_name: str):
+    """
+    Removes a module block by name from main.tf for this cluster.
+    """
+    if not os.path.exists(main_tf_path):
+        print(f"⚠️  No main.tf found at {main_tf_path}")
+        return
+
+    try:
+        with open(main_tf_path, "r") as f:
+            tree = hcl2.parse(f)
+    except Exception as e:
+        print(f"❌ Failed to parse HCL: {e}")
+        return
+
+    # Process tree to remove target module block
+    new_tree, removed = simple_remove_module(tree, module_name)
+
+    # If no modules were removed
+    if not removed:
+        print(f"⚠️  No module named '{module_name}' found in {main_tf_path}")
+        return
+
+    try:
+        # Reconstruct HCL
+        new_source = hcl2.writes(new_tree)
+
+        # Write back to file
+        with open(main_tf_path, "w") as f:
+            f.write(new_source)
+
+        print(f"🗑️  Removed module '{module_name}' from {main_tf_path}")
+    except Exception as e:
+        print(f"❌ Failed to reconstruct HCL: {e}")
+        # Print more detailed error information
+        import traceback
+
+        traceback.print_exc()
+
+
+def extract_template_variables(template_path):
+    """
+    Extract variables from a Terraform template file using hcl2.
+
+    Args:
+        template_path: Path to the Terraform template file
+
+    Returns:
+        Dictionary of variable names to their complete configuration
+
+    Raises:
+        ValueError: If the template cannot be parsed or variables cannot be extracted
+    """
+    try:
+        with open(template_path, "r") as f:
+            parsed = hcl2.load(f)
+
+        variables = {}
+
+        # Extract variables from the list of variable blocks
+        if "variable" in parsed:
+            for var_block in parsed["variable"]:
+                # Each var_block is a dict with a single key (the variable name)
+                for var_name, var_config in var_block.items():
+                    variables[var_name] = var_config
+
+        return variables
+
+    except FileNotFoundError:
+        print(f"Warning: Template file not found: {template_path}")
+        return {}
+
+    except Exception as e:
+        error_msg = f"Failed to extract variables from {template_path}: {e}"
+        print(f"Error: {error_msg}")
+        raise ValueError(error_msg)

cluster_builder-0.2.0/cluster_builder/utils/logging.py

@@ -0,0 +1,46 @@
+"""
+Logging configuration for the cluster builder.
+"""
+
+import logging
+import sys
+from typing import Optional
+
+
+def configure_logging(
+    level: int = logging.INFO, log_file: Optional[str] = None
+) -> None:
+    """
+    Configure or reconfigure logging for the cluster builder.
+
+    Args:
+        level: Logging level (default: INFO)
+        log_file: Optional path to log file
+    """
+    # Root logger configuration
+    root_logger = logging.getLogger()
+    root_logger.setLevel(level)
+
+    # Clear existing handlers to avoid duplicates
+    for handler in root_logger.handlers[:]:
+        root_logger.removeHandler(handler)
+
+    # Create formatter
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    root_logger.addHandler(console_handler)
+
+    # File handler (if log_file is provided)
+    if log_file:
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(formatter)
+        root_logger.addHandler(file_handler)
+
+    # Configure swarmchestrate logger
+    logger = logging.getLogger("swarmchestrate")
+    logger.setLevel(level)

{cluster_builder-0.1.1 → cluster_builder-0.2.0}/cluster_builder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cluster-builder
-Version: 0.1.1
+Version: 0.2.0
 Summary: Swarmchestrate cluster builder
 Author-email: Gunjan <G.Kotak@westminster.ac.uk>, Jay <J.Deslauriers@westminster.ac.uk>
 License: Apache2

cluster_builder-0.2.0/cluster_builder.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+pyproject.toml
+cluster_builder/__init__.py
+cluster_builder/swarmchestrate.py
+cluster_builder.egg-info/PKG-INFO
+cluster_builder.egg-info/SOURCES.txt
+cluster_builder.egg-info/dependency_links.txt
+cluster_builder.egg-info/requires.txt
+cluster_builder.egg-info/top_level.txt
+cluster_builder/config/__init__.py
+cluster_builder/config/cluster.py
+cluster_builder/config/postgres.py
+cluster_builder/infrastructure/__init__.py
+cluster_builder/infrastructure/executor.py
+cluster_builder/templates/__init__.py
+cluster_builder/templates/manager.py
+cluster_builder/utils/__init__.py
+cluster_builder/utils/hcl.py
+cluster_builder/utils/logging.py
+tests/test_hcl.py

{cluster_builder-0.1.1 → cluster_builder-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cluster-builder"
-version = "0.1.1"
+version = "0.2.0"
 description = "Swarmchestrate cluster builder"
 readme = "README.md"
 authors = [
@@ -21,5 +21,6 @@ dependencies = [
     "python-dotenv"
 ]
 
-[tool.setuptools]
-packages = ["cluster_builder"]
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["cluster_builder*"]

cluster_builder-0.1.1/cluster_builder.egg-info/SOURCES.txt

@@ -1,11 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-cluster_builder/__init__.py
-cluster_builder/swarmchestrate.py
-cluster_builder.egg-info/PKG-INFO
-cluster_builder.egg-info/SOURCES.txt
-cluster_builder.egg-info/dependency_links.txt
-cluster_builder.egg-info/requires.txt
-cluster_builder.egg-info/top_level.txt
-tests/test_hcl.py