cumulusci-plus 5.0.6__tar.gz → 5.0.8.dev0__tar.gz

{cumulusci_plus-5.0.6 → cumulusci_plus-5.0.8.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cumulusci-plus
-Version: 5.0.6
+Version: 5.0.8.dev0
 Summary: Build and release tools for Salesforce developers
 Project-URL: Homepage, https://github.com/jorgesolebur/CumulusCI
 Project-URL: Changelog, https://cumulusci.readthedocs.io/en/stable/history.html

cumulusci_plus-5.0.8.dev0/cumulusci/__about__.py

@@ -0,0 +1 @@
+__version__ = "5.0.8.dev0"

{cumulusci_plus-5.0.6 → cumulusci_plus-5.0.8.dev0}/cumulusci/cli/cci.py

@@ -1,7 +1,9 @@
 import code
 import contextlib
+import os
 import pdb
 import runpy
+import signal
 import sys
 import traceback
 
@@ -43,6 +45,78 @@ SUGGEST_ERROR_COMMAND = (
 
 USAGE_ERRORS = (CumulusCIUsageError, click.UsageError)
 
+# Global variable to track the context stack for cleanup on signal
+_exit_stack = None
+_signal_handler_active = False  # Flag to prevent recursive signal handler calls
+
+
+def _signal_handler(signum, frame):
+    """Handle termination signals.
+
+    This handler ensures the CLI exits gracefully with a failure code when
+    receiving SIGTERM or SIGINT signals, such as when an Azure DevOps pipeline
+    is cancelled. It also terminates all child processes in the process group.
+    """
+    global _signal_handler_active
+
+    # Prevent recursive signal handler calls
+    if _signal_handler_active:
+        return
+
+    _signal_handler_active = True
+
+    console = Console()
+
+    signal_names = {signal.SIGTERM: "SIGTERM", signal.SIGINT: "SIGINT"}
+
+    signal_name = signal_names.get(signum, f"signal {signum}")
+
+    console.print(
+        f"\n[yellow]Received {signal_name} - CumulusCI is being terminated[/yellow]"
+    )
+    console.print(
+        "[yellow]Exiting with failure code due to external cancellation.[/yellow]"
+    )
+
+    # Clean up managed resources
+    if _exit_stack:
+        try:
+            _exit_stack.close()
+        except Exception as e:
+            console.print(f"[red]Error during cleanup: {e}[/red]")
+
+    # Terminate child processes in the process group
+    try:
+        console.print("[yellow]Terminating child processes...[/yellow]")
+
+        # Temporarily ignore the signal to prevent recursion
+        old_handler = signal.signal(signum, signal.SIG_IGN)
+
+        try:
+            # Only use process group termination on Unix systems
+            if hasattr(os, "getpgrp") and hasattr(os, "killpg"):
+                pgrp = os.getpgrp()
+                # Send signal to all processes in the group except ourselves
+                os.killpg(pgrp, signum)
+            else:
+                # On Windows, we can't use process groups, so just log the attempt
+                console.print(
+                    "[yellow]Process group termination not supported on this platform[/yellow]"
+                )
+        finally:
+            # Restore the original signal handler
+            signal.signal(signum, old_handler)
+
+    except ProcessLookupError:
+        # Process group may not exist or may already be terminated
+        pass
+    except Exception as e:
+        console.print(f"[red]Warning: Error terminating child processes: {e}[/red]")
+
+    # Exit with appropriate failure code
+    exit_code = 143 if signum == signal.SIGTERM else 130  # Standard exit codes
+    sys.exit(exit_code)
+
 
 #
 # Root command
@@ -54,7 +128,25 @@ def main(args=None):
 
     This wraps the `click` library in order to do some initialization and centralized error handling.
     """
+    global _exit_stack
+
+    # Create a new process group so we can terminate all child processes
+    # when we receive a termination signal
+    try:
+        if hasattr(os, "setpgrp"):
+            # On Unix systems, create a new process group
+            os.setpgrp()
+    except Exception:
+        # On Windows or if setpgrp fails, continue without process group
+        pass
+
+    # Set up signal handlers for graceful termination
+    signal.signal(signal.SIGTERM, _signal_handler)
+    signal.signal(signal.SIGINT, _signal_handler)
+
     with contextlib.ExitStack() as stack:
+        _exit_stack = stack  # Store reference for signal handler cleanup
+
         args = args or sys.argv
 
         # (If enabled) set up requests to validate certs using system CA certs instead of certifi
@@ -98,15 +190,20 @@ def main(args=None):
                 sys.exit(1)
             except Exception as e:
                 if debug:
+                    console = Console()
                     show_debug_info()
+                    console.print(
+                        f"\n[red bold]Debug info for bug reports:\n{traceback.format_exc()}"
+                    )
+                    sys.exit(1)
                 else:
                     handle_exception(
-                        e,
-                        is_error_command,
-                        tempfile_path,
-                        should_show_stacktraces,
+                        e, is_error_command, tempfile_path, should_show_stacktraces
                     )
-                sys.exit(1)
+                    sys.exit(1)
+
+        # Clear the global reference when exiting normally
+        _exit_stack = None
 
 
 def handle_exception(

{cumulusci_plus-5.0.6 → cumulusci_plus-5.0.8.dev0}/cumulusci/cli/tests/test_cci.py

@@ -1,9 +1,8 @@
 import contextlib
 import io
 import os
-import shutil
+import signal
 import sys
-import tempfile
 from pathlib import Path
 from unittest import mock
 
@@ -26,22 +25,11 @@ CONSOLE = mock.Mock()
 
 
 @pytest.fixture(autouse=True)
-def env_config():
-    config = {
-        "global_tempdir": tempfile.gettempdir(),
-        "tempdir": tempfile.mkdtemp(),
-        "environ_mock": mock.patch.dict(
-            os.environ, {"HOME": tempfile.mkdtemp(), "CUMULUSCI_KEY": ""}
-        ),
-    }
-    # setup
-    config["environ_mock"].start()
-    assert config["global_tempdir"] in os.environ["HOME"]
-    yield config
-    # tear down
-    assert config["global_tempdir"] in os.environ["HOME"]
-    config["environ_mock"].stop()
-    shutil.rmtree(config["tempdir"])
+def reset_signal_handler_flag():
+    """Reset signal handler flag to ensure clean state for tests"""
+    cci._signal_handler_active = False
+    yield
+    cci._signal_handler_active = False
 
 
 @mock.patch("cumulusci.cli.cci.tee_stdout_stderr")
@@ -266,7 +254,9 @@ def test_cci_org_default__no_orgname(
 DEPLOY_CLASS_PATH = f"cumulusci.tasks.salesforce.Deploy{'.Deploy' if sys.version_info >= (3, 11) else ''}"
 
 
-@mock.patch("cumulusci.cli.cci.init_logger", mock.Mock())
+@mock.patch(
+    "cumulusci.cli.cci.init_logger", mock.Mock()
+)  # side effects break other tests
 @mock.patch("cumulusci.cli.cci.tee_stdout_stderr", mock.MagicMock())
 @mock.patch(f"{DEPLOY_CLASS_PATH}.__call__", mock.Mock())
 @mock.patch("sys.exit", mock.Mock())
@@ -543,3 +533,264 @@ def test_dash_dash_version(
 
     cci.main(["cci", "--version"])
     assert len(show_version_info.mock_calls) == 2
+
+
+@mock.patch("sys.exit")
+@mock.patch("cumulusci.cli.cci.Console")
+@mock.patch("os.killpg", create=True)
+@mock.patch("os.getpgrp", create=True)
+@mock.patch("signal.signal")
+def test_signal_handler_terminates_process_group(
+    mock_signal, mock_getpgrp, mock_killpg, mock_console, mock_exit
+):
+    """Test that the signal handler terminates the process group"""
+    console_instance = mock_console.return_value
+    mock_getpgrp.return_value = 1234  # Mock process group ID
+
+    # Mock the global exit stack
+    mock_exit_stack = mock.Mock()
+    with mock.patch.object(cci, "_exit_stack", mock_exit_stack):
+        # Mock hasattr to return True for Unix functions
+        with mock.patch("builtins.hasattr", return_value=True):
+            # Call the signal handler with SIGTERM
+            cci._signal_handler(signal.SIGTERM, None)
+
+            # Verify console output
+            console_instance.print.assert_any_call(
+                "\n[yellow]Received SIGTERM - CumulusCI is being terminated[/yellow]"
+            )
+            console_instance.print.assert_any_call(
+                "[yellow]Exiting with failure code due to external cancellation.[/yellow]"
+            )
+            console_instance.print.assert_any_call(
+                "[yellow]Terminating child processes...[/yellow]"
+            )
+
+            # Verify cleanup was called
+            mock_exit_stack.close.assert_called_once()
+
+            # Verify signal was temporarily ignored and then restored
+            mock_signal.assert_called()
+
+            # Verify process group was terminated
+            mock_getpgrp.assert_called_once()
+            mock_killpg.assert_called_once_with(1234, signal.SIGTERM)
+
+            # Verify exit with correct code
+            mock_exit.assert_called_once_with(143)
+
+
+@mock.patch("sys.exit")
+@mock.patch("cumulusci.cli.cci.Console")
+@mock.patch("os.killpg", create=True)
+@mock.patch("os.getpgrp", create=True)
+@mock.patch("signal.signal")
+def test_signal_handler_sigint(
+    mock_signal, mock_getpgrp, mock_killpg, mock_console, mock_exit
+):
+    """Test that the signal handler properly handles SIGINT"""
+    console_instance = mock_console.return_value
+    mock_getpgrp.return_value = 1234
+
+    # Mock the global exit stack
+    mock_exit_stack = mock.Mock()
+    with mock.patch.object(cci, "_exit_stack", mock_exit_stack):
+        # Mock hasattr to return True for Unix functions
+        with mock.patch("builtins.hasattr", return_value=True):
+            # Call the signal handler with SIGINT
+            cci._signal_handler(signal.SIGINT, None)
+
+            # Verify console output
+            console_instance.print.assert_any_call(
+                "\n[yellow]Received SIGINT - CumulusCI is being terminated[/yellow]"
+            )
+
+            # Verify process group was terminated with SIGINT
+            mock_killpg.assert_called_once_with(1234, signal.SIGINT)
+
+            # Verify exit with correct code for SIGINT
+            mock_exit.assert_called_once_with(130)
+
+
+@mock.patch("sys.exit")
+@mock.patch("cumulusci.cli.cci.Console")
+def test_signal_handler_prevents_recursion(mock_console, mock_exit):
+    """Test that the signal handler prevents recursive calls"""
+    console_instance = mock_console.return_value
+
+    # Set the flag to simulate handler already active
+    with mock.patch.object(cci, "_signal_handler_active", True):
+        # Call the signal handler
+        cci._signal_handler(signal.SIGTERM, None)
+
+        # Verify no console output (handler should return immediately)
+        console_instance.print.assert_not_called()
+
+        # Verify no exit call
+        mock_exit.assert_not_called()
+
+
+@mock.patch("sys.exit")
+@mock.patch("cumulusci.cli.cci.Console")
+@mock.patch("os.killpg", create=True)
+@mock.patch("os.getpgrp", create=True)
+@mock.patch("signal.signal")
+def test_signal_handler_handles_killpg_error(
+    mock_signal, mock_getpgrp, mock_killpg, mock_console, mock_exit
+):
+    """Test that the signal handler handles errors from killpg gracefully"""
+    console_instance = mock_console.return_value
+    mock_getpgrp.return_value = 1234
+    mock_killpg.side_effect = OSError("Process group not found")
+
+    # Mock hasattr to return True for Unix functions
+    with mock.patch("builtins.hasattr", return_value=True):
+        # Call the signal handler with SIGTERM
+        cci._signal_handler(signal.SIGTERM, None)
+
+    # Verify error message was printed
+    console_instance.print.assert_any_call(
+        "[red]Warning: Error terminating child processes: Process group not found[/red]"
+    )
+
+    # Verify it still exits with correct code
+    mock_exit.assert_called_once_with(143)
+
+
+@mock.patch("sys.exit")
+@mock.patch("cumulusci.cli.cci.Console")
+def test_signal_handler_without_process_group_support(mock_console, mock_exit):
+    """Test that the signal handler works on Windows where process groups aren't supported"""
+    console_instance = mock_console.return_value
+
+    # Mock the global exit stack
+    mock_exit_stack = mock.Mock()
+    with mock.patch.object(cci, "_exit_stack", mock_exit_stack):
+        # Mock hasattr to return False for Unix functions (like on Windows)
+        with mock.patch("builtins.hasattr", return_value=False):
+            # Call the signal handler with SIGTERM
+            cci._signal_handler(signal.SIGTERM, None)
+
+            # Verify console output
+            console_instance.print.assert_any_call(
+                "\n[yellow]Received SIGTERM - CumulusCI is being terminated[/yellow]"
+            )
+            console_instance.print.assert_any_call(
+                "[yellow]Exiting with failure code due to external cancellation.[/yellow]"
+            )
+            console_instance.print.assert_any_call(
+                "[yellow]Terminating child processes...[/yellow]"
+            )
+            console_instance.print.assert_any_call(
+                "[yellow]Process group termination not supported on this platform[/yellow]"
+            )
+
+            # Verify cleanup was called
+            mock_exit_stack.close.assert_called_once()
+
+            # Verify exit with correct code
+            mock_exit.assert_called_once_with(143)
+
+
+@mock.patch("os.setpgrp", create=True)
+def test_main_creates_process_group(mock_setpgrp):
+    """Test that main() creates a new process group"""
+    # Mock dependencies to avoid actual CLI execution
+    with mock.patch.multiple(
+        "cumulusci.cli.cci",
+        signal=mock.Mock(),
+        init_requests_trust=mock.Mock(),
+        check_latest_version=mock.Mock(),
+        check_latest_plugins=mock.Mock(),
+        get_tempfile_logger=mock.Mock(return_value=(mock.Mock(), "tempfile.log")),
+        tee_stdout_stderr=mock.Mock(
+            return_value=mock.Mock(__enter__=mock.Mock(), __exit__=mock.Mock())
+        ),
+        set_debug_mode=mock.Mock(
+            return_value=mock.Mock(__enter__=mock.Mock(), __exit__=mock.Mock())
+        ),
+        CliRuntime=mock.Mock(),
+        init_logger=mock.Mock(),
+        cli=mock.Mock(),
+    ):
+        try:
+            cci.main(["cci", "version"])
+        except SystemExit:
+            pass  # Expected for version command
+
+        # Verify process group was created
+        mock_setpgrp.assert_called_once()
+
+
+@mock.patch("os.setpgrp", create=True)
+def test_main_handles_setpgrp_error(mock_setpgrp):
+    """Test that main() handles setpgrp errors gracefully"""
+    mock_setpgrp.side_effect = OSError("Operation not permitted")
+
+    # Mock dependencies to avoid actual CLI execution
+    with mock.patch.multiple(
+        "cumulusci.cli.cci",
+        signal=mock.Mock(),
+        init_requests_trust=mock.Mock(),
+        check_latest_version=mock.Mock(),
+        check_latest_plugins=mock.Mock(),
+        get_tempfile_logger=mock.Mock(return_value=(mock.Mock(), "tempfile.log")),
+        tee_stdout_stderr=mock.Mock(
+            return_value=mock.Mock(__enter__=mock.Mock(), __exit__=mock.Mock())
+        ),
+        set_debug_mode=mock.Mock(
+            return_value=mock.Mock(__enter__=mock.Mock(), __exit__=mock.Mock())
+        ),
+        CliRuntime=mock.Mock(),
+        init_logger=mock.Mock(),
+        cli=mock.Mock(),
+    ):
+        try:
+            # Should not raise an exception even if setpgrp fails
+            cci.main(["cci", "version"])
+        except SystemExit:
+            pass  # Expected for version command
+        except OSError:
+            pytest.fail("main() should handle setpgrp errors gracefully")
+
+        # Verify setpgrp was attempted
+        mock_setpgrp.assert_called_once()
+
+
+@mock.patch("signal.signal")
+def test_main_registers_signal_handlers(mock_signal):
+    """Test that main() registers signal handlers"""
+    # Create a proper context manager mock
+    context_manager_mock = mock.Mock()
+    context_manager_mock.__enter__ = mock.Mock(return_value=context_manager_mock)
+    context_manager_mock.__exit__ = mock.Mock(return_value=None)
+
+    # Create another context manager mock for set_debug_mode
+    debug_context_mock = mock.Mock()
+    debug_context_mock.__enter__ = mock.Mock(return_value=debug_context_mock)
+    debug_context_mock.__exit__ = mock.Mock(return_value=None)
+
+    # Mock dependencies to avoid actual CLI execution
+    with mock.patch.multiple(
+        "cumulusci.cli.cci",
+        init_requests_trust=mock.Mock(),
+        check_latest_version=mock.Mock(),
+        check_latest_plugins=mock.Mock(),
+        get_tempfile_logger=mock.Mock(return_value=(mock.Mock(), "tempfile.log")),
+        tee_stdout_stderr=mock.Mock(return_value=context_manager_mock),
+        set_debug_mode=mock.Mock(return_value=debug_context_mock),
+        CliRuntime=mock.Mock(),
+        init_logger=mock.Mock(),
+        cli=mock.Mock(),
+    ):
+        try:
+            cci.main(["cci", "version"])
+        except SystemExit:
+            pass  # Expected for version command
+
+        # Verify signal handlers were registered
+        expected_calls = [
+            mock.call(signal.SIGTERM, cci._signal_handler),
+            mock.call(signal.SIGINT, cci._signal_handler),
+        ]
+        mock_signal.assert_has_calls(expected_calls, any_order=True)

{cumulusci_plus-5.0.6 → cumulusci_plus-5.0.8.dev0}/cumulusci/core/dependencies/base.py

@@ -1,5 +1,6 @@
 import contextlib
 from abc import ABC, abstractmethod
+from datetime import datetime
 from typing import List, Optional, Type
 from zipfile import ZipFile
 
@@ -9,11 +10,13 @@ from cumulusci.core.config import OrgConfig
 from cumulusci.core.config.project_config import BaseProjectConfig
 from cumulusci.core.dependencies.utils import TaskContext
 from cumulusci.core.exceptions import DependencyResolutionError, VcsNotFoundError
+from cumulusci.core.flowrunner import FlowCallback, FlowCoordinator
 from cumulusci.core.sfdx import (
     SourceFormat,
     convert_sfdx_source,
     get_source_format_for_zipfile,
 )
+from cumulusci.core.utils import format_duration
 from cumulusci.salesforce_api.metadata import ApiDeploy
 from cumulusci.salesforce_api.package_zip import MetadataPackageZipBuilder
 from cumulusci.utils import download_extract_vcs_from_repo, temporary_dir
@@ -153,11 +156,8 @@ class DynamicDependency(Dependency, ABC):
         resolve_dependency(self, context, strategies)
 
 
-class UnmanagedDependency(StaticDependency, ABC):
-    """Abstract base class for static, unmanaged dependencies."""
-
+class UnmanagedStaticDependency(StaticDependency, ABC):
     unmanaged: Optional[bool] = None
-    subfolder: Optional[str] = None
     namespace_inject: Optional[str] = None
     namespace_strip: Optional[str] = None
     collision_check: Optional[bool] = None
@@ -171,6 +171,12 @@ class UnmanagedDependency(StaticDependency, ABC):
 
         return self.unmanaged
 
+
+class UnmanagedDependency(UnmanagedStaticDependency, ABC):
+    """Abstract base class for static, unmanaged dependencies."""
+
+    subfolder: Optional[str] = None
+
     @abstractmethod
     def _get_zip_src(self, context: BaseProjectConfig) -> ZipFile:
         pass
@@ -378,6 +384,28 @@ class VcsDynamicDependency(BaseVcsDynamicDependency, ABC):
 
         return values
 
+    def _flatten_dependency_flow(
+        self,
+        remote_config: BaseProjectConfig,
+        flow_type: str,
+        managed: bool,
+        namespace: Optional[str],
+    ) -> List[StaticDependency]:
+
+        if remote_config.project.get(flow_type):
+            return [
+                UnmanagedVcsDependencyFlow(
+                    url=self.url,
+                    vcs=self.vcs,
+                    commit=self.ref,
+                    flow_name=remote_config.project.get(flow_type),
+                    unmanaged=not managed,
+                    namespace_inject=namespace if namespace and managed else None,
+                    namespace_strip=namespace if namespace and not managed else None,
+                )
+            ]
+        return []
+
     def _flatten_unpackaged(
         self,
         repo: AbstractRepo,
@@ -454,6 +482,17 @@ class VcsDynamicDependency(BaseVcsDynamicDependency, ABC):
         # Check for unmanaged flag on a namespaced package
         managed = bool(namespace and not self.unmanaged)
 
+        # Look for any flow to executed in project config
+        # Pre flows will run to dynamically generate metadata and deploy.
+        deps.extend(
+            self._flatten_dependency_flow(
+                package_config,
+                "dependency_flow_pre",
+                managed=managed,
+                namespace=namespace,
+            )
+        )
+
         # Look for subfolders under unpackaged/pre
         # unpackaged/pre is always deployed unmanaged, no namespace manipulation.
         deps.extend(
@@ -482,6 +521,17 @@ class VcsDynamicDependency(BaseVcsDynamicDependency, ABC):
         else:
             deps.append(self.package_dependency)
 
+        # Look for any flow to executed in project config
+        # Pre flows will run to dynamically generate metadata and deploy.
+        deps.extend(
+            self._flatten_dependency_flow(
+                package_config,
+                "dependency_flow_post",
+                managed=managed,
+                namespace=namespace,
+            )
+        )
+
         # We always inject the project's namespace into unpackaged/post metadata if managed
         deps.extend(
             self._flatten_unpackaged(
@@ -559,3 +609,73 @@ class UnmanagedVcsDependency(UnmanagedDependency, ABC):
         )
 
         return f"{self.url}{subfolder} @{self.ref}"
+
+
+class UnmanagedVcsDependencyFlow(UnmanagedStaticDependency, ABC):
+    vcs: str
+    url: AnyUrl
+    commit: str
+    flow_name: str
+    callback_class = FlowCallback
+
+    # Add these fields to support namespace manipulation
+    namespace_inject: Optional[str] = None
+    namespace_strip: Optional[str] = None
+    password_env_name: Optional[str] = None
+
+    @property
+    def name(self):
+        return f"Deploy {self.url} Flow: {self.flow_name}"
+
+    @property
+    def description(self):
+        return f"{self.url} Flow: {self.flow_name} @{self.commit}"
+
+    def install(self, context: BaseProjectConfig, org: OrgConfig):
+        context.logger.info(f"Deploying dependency Flow from {self.description}")
+
+        from cumulusci.utils.yaml.cumulusci_yml import VCSSourceModel
+        from cumulusci.vcs.vcs_source import VCSSource
+
+        # Get the VCS Source class from the vcs field.
+        source_model = VCSSourceModel(
+            vcs=self.vcs,
+            url=self.url,
+            commit=self.commit,
+            allow_remote_code=context.allow_remote_code,
+        )
+        vcs_source = VCSSource.create(context, source_model)
+
+        # Fetch the data and get remote project config.
+        context.logger.info(f"Fetching from {vcs_source}")
+        project_config = vcs_source.fetch()
+
+        project_config.set_keychain(context.keychain)
+        project_config.source = vcs_source
+
+        # If I can't load remote code, make sure that my
+        # included repos can't either.
+        if vcs_source.allow_remote_code:
+            project_config._add_tasks_directory_to_python_path()
+
+        # Run the flow.
+        flow_config = project_config.get_flow(self.flow_name)
+        flow_config.name = self.flow_name
+
+        coordinator = FlowCoordinator(
+            project_config,
+            flow_config,
+            name=flow_config.name,
+            options={
+                "unmanaged": self._get_unmanaged(org),
+                "namespace_inject": self.namespace_inject,
+                "namespace_strip": self.namespace_strip,
+            },
+            skip=None,
+            callbacks=self.callback_class(),
+        )
+
+        start_time = datetime.now()
+        coordinator.run(org)
+        duration = datetime.now() - start_time
+        context.logger.info(f"Ran {self.flow_name} in {format_duration(duration)}")