spaceforge 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

spaceforge/__init__.py

@@ -4,10 +4,18 @@ Spaceforge - Spacelift Plugin Framework
 A Python framework for building Spacelift plugins with hook-based functionality.
 """
 
-from ._version import get_version
-from .cls import Binary, Context, MountedFile, Parameter, Policy, Variable, Webhook
-from .plugin import SpaceforgePlugin
-from .runner import PluginRunner
+from spaceforge._version import get_version
+from spaceforge.cls import (
+    Binary,
+    Context,
+    MountedFile,
+    Parameter,
+    Policy,
+    Variable,
+    Webhook,
+)
+from spaceforge.plugin import SpaceforgePlugin
+from spaceforge.runner import PluginRunner
 
 __version__ = get_version()
 __all__ = [

spaceforge/__main__.py

@@ -4,9 +4,9 @@ Main entry point for spaceforge module.
 
 import click
 
-from ._version import get_version
-from .generator import generate_command
-from .runner import runner_command
+from spaceforge._version import get_version
+from spaceforge.generator import generate_command
+from spaceforge.runner import runner_command
 
 
 @click.group()

spaceforge/_version.py

@@ -3,7 +3,6 @@ Dynamic version detection from git tags.
 """
 
 import subprocess
-import sys
 from typing import Optional
 
 

spaceforge/_version_scm.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.2'
-__version_tuple__ = version_tuple = (0, 0, 2)
+__version__ = version = '0.0.4'
+__version_tuple__ = version_tuple = (0, 0, 4)
 
 __commit_id__ = commit_id = None

spaceforge/cls.py

@@ -1,3 +1,4 @@
+import uuid
 from typing import Dict, List, Literal, Optional
 
 from pydantic import Field
@@ -19,8 +20,7 @@ class Binary:
 
     Attributes:
         name (str): The name of the binary file.
-        path (str): The path to the binary file.
-        sensitive (bool): Whether the binary file is sensitive.
+        download_urls (Dict[BinaryType, str]): A dictionary mapping binary types to their download URLs.
     """
 
     name: str
@@ -38,6 +38,7 @@ class Parameter:
         sensitive (bool): Whether the parameter contains sensitive information.
         required (bool): Whether the parameter is required.
         default (Optional[str]): The default value of the parameter, if any. (required if sensitive is False)
+        id (str): Unique identifier for the parameter.
     """
 
     name: str
@@ -45,6 +46,7 @@ class Parameter:
     sensitive: bool = False
     required: bool = False
     default: Optional[str] = None
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
 
     def __post_init__(self) -> None:
         if not self.required and self.default is None:
@@ -116,7 +118,7 @@ class Context:
     Attributes:
         name_prefix (str): The name of the context, will be appended with a unique ID.
         description (str): A description of the context.
-        labels (dict): Labels associated with the context.
+        labels (Optional[List[str]]): Labels associated with the context.
         env (list): List of variables associated with the context.
         hooks (dict): Hooks associated with the context.
     """
@@ -126,7 +128,7 @@ class Context:
     env: Optional[List[Variable]] = optional_field
     mounted_files: Optional[List[MountedFile]] = optional_field
     hooks: Optional[Dict[HookType, List[str]]] = optional_field
-    labels: Optional[Dict[str, str]] = optional_field
+    labels: Optional[List[str]] = optional_field
 
 
 @pydantic_dataclass
@@ -137,14 +139,14 @@ class Webhook:
     Attributes:
         name_prefix (str): The name of the webhook, will be appended with a unique ID.
         endpoint (str): The URL endpoint for the webhook.
-        labels (Optional[dict]): Labels associated with the webhook.
-        secrets (Optional[list[Variable]]): List of secrets associated with the webhook.
+        labels (Optional[List[str]]): Labels associated with the webhook.
+        secret (str): the ID of the parameter where the webhook secret is retrieved from
     """
 
     name_prefix: str
     endpoint: str
-    labels: Optional[Dict[str, str]] = optional_field
-    secrets: Optional[List[Variable]] = optional_field
+    secretFromParameter: str
+    labels: Optional[List[str]] = optional_field
 
 
 @pydantic_dataclass
@@ -156,13 +158,13 @@ class Policy:
         name_prefix (str): The name of the policy, will be appended with a unique ID.
         type (str): The type of the policy (e.g., "terraform", "kubernetes").
         body (str): The body of the policy, typically a configuration or script.
-        labels (Optional[dict[str, str]]): Labels associated with the policy.
+        labels (Optional[List[str]]): Labels associated with the policy.
     """
 
     name_prefix: str
     type: str
     body: str
-    labels: Optional[Dict[str, str]] = optional_field
+    labels: Optional[List[str]] = optional_field
 
 
 @pydantic_dataclass
@@ -171,19 +173,21 @@ class PluginManifest:
     A class to represent the manifest of a Spacelift plugin.
 
     Attributes:
-        name_prefix (str): The name of the plugin, will be appended with a unique ID.
+        name (str): The name of the plugin, will be appended with a unique ID.
         description (str): A description of the plugin.
         author (str): The author of the plugin.
+        labels (list[str]): List of labels for the plugin.
         parameters (list[Parameter]): List of parameters for the plugin.
         contexts (list[Context]): List of contexts for the plugin.
         webhooks (list[Webhook]): List of webhooks for the plugin.
         policies (list[Policy]): List of policies for the plugin.
     """
 
-    name_prefix: str
+    name: str
     version: str
     description: str
     author: str
+    labels: Optional[List[str]] = optional_field
     parameters: Optional[List[Parameter]] = optional_field
     contexts: Optional[List[Context]] = optional_field
     webhooks: Optional[List[Webhook]] = optional_field

spaceforge/conftest.py

@@ -0,0 +1,89 @@
+"""Shared test fixtures for spaceforge tests."""
+
+import os
+import tempfile
+from typing import Dict, Generator, List
+from unittest.mock import Mock
+
+import pytest
+
+from spaceforge.plugin import SpaceforgePlugin
+
+
+@pytest.fixture
+def temp_dir() -> Generator[str, None, None]:
+    """Provide a temporary directory for test files."""
+    temp_dir = tempfile.mkdtemp()
+    yield temp_dir
+    import shutil
+
+    shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+@pytest.fixture
+def test_plugin_content() -> str:
+    """Basic test plugin content."""
+    return """
+from spaceforge import SpaceforgePlugin, Parameter
+
+class TestPlugin(SpaceforgePlugin):
+    __plugin_name__ = "test"
+    __version__ = "1.0.0"
+    __author__ = "Test Author"
+    
+    __parameters__ = [
+        Parameter(
+            name="test_param",
+            description="Test parameter",
+            required=False,
+            default="default_value"
+        )
+    ]
+    
+    def after_plan(self) -> None:
+        pass
+"""
+
+
+@pytest.fixture
+def test_plugin_file(temp_dir: str, test_plugin_content: str) -> str:
+    """Create a test plugin file."""
+    plugin_path = os.path.join(temp_dir, "plugin.py")
+    with open(plugin_path, "w") as f:
+        f.write(test_plugin_content)
+    return plugin_path
+
+
+@pytest.fixture
+def mock_env() -> Dict[str, str]:
+    """Common test environment variables."""
+    return {
+        "SPACELIFT_API_TOKEN": "test_token",
+        "TF_VAR_spacelift_graphql_endpoint": "https://test.spacelift.io",
+    }
+
+
+@pytest.fixture
+def mock_api_response() -> Mock:
+    """Mock API response for testing."""
+    mock_response = Mock()
+    mock_response.read.return_value = b'{"data": {"test": "result"}}'
+    return mock_response
+
+
+class ExampleTestPlugin(SpaceforgePlugin):
+    """Reusable test plugin class."""
+
+    __plugin_name__ = "example"
+    __version__ = "1.0.0"
+    __author__ = "Test"
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.hook_calls: List[str] = []
+
+    def after_plan(self) -> None:
+        self.hook_calls.append("after_plan")
+
+    def before_apply(self) -> None:
+        self.hook_calls.append("before_apply")

spaceforge/generator.py

@@ -4,9 +4,10 @@ YAML generator for Spacelift plugins.
 
 import importlib.util
 import os
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union
 
 import yaml
+from jinja2 import Environment, PackageLoader, select_autoescape
 
 if TYPE_CHECKING:
     from .plugin import SpaceforgePlugin
@@ -46,6 +47,10 @@ class PluginGenerator:
         self.plugin_class: Optional[Type[SpaceforgePlugin]] = None
         self.plugin_instance: Optional[SpaceforgePlugin] = None
         self.plugin_working_directory: Optional[str] = None
+        self.config: Optional[Dict[str, Any]] = None
+        self.jinja = Environment(
+            loader=PackageLoader("spaceforge"), autoescape=select_autoescape()
+        )
 
     def load_plugin(self) -> None:
         """Load the plugin class from the specified path."""
@@ -80,8 +85,15 @@ class PluginGenerator:
         self.plugin_working_directory = (
             "/mnt/workspace/plugins/" + plugin_class.__plugin_name__.lower()
         )
+        self.config = {
+            "setup_virtual_env": (
+                f"cd {self.plugin_working_directory} && python -m venv ./venv && "
+                + "source venv/bin/activate && (command -v spaceforge &> /dev/null || pip install spaceforge)"
+            ),
+            "plugin_mounted_path": f"{self.plugin_working_directory}/{os.path.basename(self.plugin_path)}",
+        }
 
-    def get_plugin_metadata(self) -> Dict[str, str]:
+    def get_plugin_metadata(self) -> Dict[str, Union[str, List[str]]]:
         """Extract metadata from the plugin class."""
         if self.plugin_class is None:
             raise ValueError("Plugin class not loaded. Call load_plugin() first.")
@@ -97,6 +109,7 @@ class PluginGenerator:
                 self.plugin_class.__name__.lower().replace("plugin", ""),
             ),
             "version": getattr(self.plugin_class, "__version__", "1.0.0"),
+            "labels": getattr(self.plugin_class, "__labels__", []),
             "description": doc
             or f"A Spacelift plugin built with {self.plugin_class.__name__}",
             "author": getattr(self.plugin_class, "__author__", "Unknown"),
@@ -128,22 +141,27 @@ class PluginGenerator:
 
         return hook_methods
 
-    def get_plugin_contexts(self) -> List[Context]:
-        """Get context definitions from the plugin class."""
-
-        change_to_working_directory = f"cd {self.plugin_working_directory}"
-        hooks = {
-            "before_init": [
-                f"mkdir -p {self.plugin_working_directory}",
-            ],
-        }
-        mounted_files = []
-
-        # Add a virtual environment before_init hook if requirements.txt exists
-        if os.path.exists("requirements.txt"):
-            hooks["before_init"].append(
-                f"{change_to_working_directory} && python -m venv ./venv && source venv/bin/activate && pip install -r requirements.txt"
+    def _add_to_mounted_files(
+        self,
+        hooks: Dict[str, List[str]],
+        mounted_files: List[MountedFile],
+        phase: str,
+        filepath: str,
+        filecontent: str,
+    ) -> None:
+        file = f"{self.plugin_working_directory}/{filepath}"
+        hooks[phase].append(f"chmod +x {file} && {file}")
+        mounted_files.append(
+            MountedFile(
+                path=f"{self.plugin_working_directory}/{filepath}",
+                content=filecontent,
+                sensitive=False,
             )
+        )
+
+    def _update_with_requirements(self, mounted_files: List[MountedFile]) -> None:
+        """Update the plugin hooks if there is a requirements.txt"""
+        if os.path.exists("requirements.txt") and self.config is not None:
             # read the requirements.txt file
             with open("requirements.txt", "r") as f:
                 mounted_files.append(
@@ -154,33 +172,80 @@ class PluginGenerator:
                     )
                 )
 
-        # Ensure the plugin file itself is mounted
-        plugin_mounted_path = (
-            f"{self.plugin_working_directory}/{os.path.basename(self.plugin_path)}"
-        )
-        if os.path.exists(self.plugin_path):
+    def _update_with_python_file(self, mounted_files: List[MountedFile]) -> None:
+        """Ensure the plugin file itself is mounted."""
+        if os.path.exists(self.plugin_path) and self.config is not None:
             with open(self.plugin_path, "r") as f:
                 mounted_files.append(
                     MountedFile(
-                        path=plugin_mounted_path,
+                        path=self.config["plugin_mounted_path"],
                         content=f.read(),
                         sensitive=False,
                     )
                 )
 
-        binary_cmd = self.generate_binary_install_command()
-        if binary_cmd != "":
-            hooks["before_init"].append(binary_cmd)
-
+    def _add_spaceforge_hooks(
+        self, hooks: Dict[str, List[str]], mounted_files: List[MountedFile]
+    ) -> None:
         # Add the spaceforge hook to actually run the plugin
+        if self.config is None:
+            raise ValueError("Plugin config not set. Call load_plugin() first.")
+
         available_hooks = self.get_available_hooks()
         for hook in available_hooks:
             # Ensure the hook exists in the first context
             if hook not in hooks:
                 hooks[hook] = []
-            hooks[hook].append(
-                f"{change_to_working_directory} && python -m spaceforge runner --plugin-file {plugin_mounted_path} {hook}"
+
+            directory = os.path.dirname(self.config["plugin_mounted_path"])
+            template = self.jinja.get_template("ensure_spaceforge_and_run.sh.j2")
+            render = template.render(
+                plugin_path=directory,
+                plugin_file=self.config["plugin_mounted_path"],
+                phase=hook,
             )
+            self._add_to_mounted_files(hooks, mounted_files, hook, f"{hook}.sh", render)
+
+    def _map_variables_to_parameters(self, contexts: List[Context]) -> None:
+        for context in contexts:
+            # Get the variables from the plugin and change the value_from_parameter to the ID of the parameter
+            # based on its name.
+            if context.env is None:
+                continue
+
+            for variable in context.env:
+                if variable.value_from_parameter:
+                    parameter_name = variable.value_from_parameter
+                    parameters = self.get_plugin_parameters()
+                    if parameters:
+                        parameter = next(
+                            (
+                                p
+                                for p in parameters
+                                if p.name == parameter_name or p.id == parameter_name
+                            ),
+                            None,
+                        )
+                        if parameter:
+                            variable.value_from_parameter = parameter.id
+                        else:
+                            raise ValueError(
+                                f"Parameter {parameter_name} not found for variable {variable.key}"
+                            )
+
+    def get_plugin_contexts(self) -> List[Context]:
+        """Get context definitions from the plugin class."""
+
+        f"cd {self.plugin_working_directory}"
+        hooks: Dict[str, List[str]] = {
+            "before_init": [f"mkdir -p {self.plugin_working_directory}"]
+        }
+        mounted_files: List[MountedFile] = []
+
+        self._update_with_requirements(mounted_files)
+        self._update_with_python_file(mounted_files)
+        self._generate_binary_install_command(hooks, mounted_files)
+        self._add_spaceforge_hooks(hooks, mounted_files)
 
         # Get the contexts and append the hooks and mounted files to it.
         if self.plugin_class is None:
@@ -208,42 +273,41 @@ class PluginGenerator:
         contexts[0].hooks.update(hooks)
         contexts[0].mounted_files.extend(mounted_files)
 
+        self._map_variables_to_parameters(contexts)
+
         return contexts
 
-    def generate_binary_install_command(self) -> str:
+    def _generate_binary_install_command(
+        self, hooks: Dict[str, List[str]], mounted_files: List[MountedFile]
+    ) -> None:
         binaries = self.get_plugin_binaries()
         if binaries is None:
-            return ""
+            return None
 
-        binary_cmd = ""
-        if len(binaries) > 0:
-            binary_cmd = f"mkdir -p {static_binary_directory} && cd {static_binary_directory} && "
         for i, binary in enumerate(binaries):
             amd64_url = binary.download_urls.get("amd64", None)
             arm64_url = binary.download_urls.get("arm64", None)
+            binary_path = f"{static_binary_directory}/{binary.name}"
             if amd64_url is None and arm64_url is None:
                 raise ValueError(
                     f"Binary {binary.name} must have at least one download URL defined (amd64 or arm64)"
                 )
 
-            binary_path = f"{static_binary_directory}/{binary.name}"
-            amd64_download_command = (
-                f"curl {amd64_url} -o {binary_path} -L && chmod +x {binary_path}"
-                if amd64_url is not None
-                else "echo 'amd64 binary not available' && exit 1"
-            )
-            arm64_download_command = (
-                f"curl {arm64_url} -o {binary_path} -L && chmod +x {binary_path}"
-                if arm64_url is not None
-                else "echo 'arm64 binary not available' && exit 1"
+            template = self.jinja.get_template("binary_install.sh.j2")
+            render = template.render(
+                binary=binary,
+                amd64_url=amd64_url,
+                arm64_url=arm64_url,
+                binary_path=binary_path,
+                static_binary_directory=static_binary_directory,
             )
-
-            binary_cmd += '([[ "$(echo "$(arch)")" == "x86_64" ]] && {} || {})'.format(
-                amd64_download_command, arm64_download_command
+            self._add_to_mounted_files(
+                hooks,
+                mounted_files,
+                "before_init",
+                f"binary_install_{binary.name}.sh",
+                render,
             )
-            if i < len(binaries) - 1:
-                binary_cmd += " && "
-        return binary_cmd
 
     def get_plugin_binaries(self) -> Optional[List[Binary]]:
         """Get binary definitions from the plugin class."""
@@ -265,10 +329,11 @@ class PluginGenerator:
         metadata = self.get_plugin_metadata()
 
         return PluginManifest(
-            name_prefix=metadata.get("name_prefix", "unknown"),
-            version=metadata.get("version", "1.0.0"),
-            description=metadata.get("description", ""),
-            author=metadata.get("author", "Unknown"),
+            name=str(metadata.get("name_prefix", "unknown")),
+            version=str(metadata.get("version", "1.0.0")),
+            description=str(metadata.get("description", "")),
+            author=str(metadata.get("author", "Unknown")),
+            labels=list(metadata.get("labels", [])),
             parameters=self.get_plugin_parameters(),
             contexts=self.get_plugin_contexts(),
             webhooks=self.get_plugin_webhooks(),