devservices 1.2.2__tar.gz → 1.2.3__tar.gz

{devservices-1.2.2 → devservices-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devservices
-Version: 1.2.2
+Version: 1.2.3
 Requires-Python: >=3.11
 License-File: LICENSE.md
 Requires-Dist: pyyaml

{devservices-1.2.2 → devservices-1.2.3}/README.md

@@ -33,7 +33,7 @@ NOTE: service-name is an optional parameter. If not provided, devservices will a
 The recommended way to install devservices is through a virtualenv in the requirements.txt. Once that is installed and a devservices config file is added, you should be able to run `devservices up` to begin local development.
 
 ```
-devservices==1.2.2
+devservices==1.2.3
 ```
 
 ### 2. Add devservices config files

{devservices-1.2.2 → devservices-1.2.3}/devservices/commands/down.py

@@ -8,6 +8,7 @@ from argparse import ArgumentParser
 from argparse import Namespace
 
 from sentry_sdk import capture_exception
+from sentry_sdk import logger as sentry_logger
 
 from devservices.constants import CONFIG_FILE_NAME
 from devservices.constants import DEPENDENCY_CONFIG_VERSION
@@ -116,6 +117,15 @@ def down(args: Namespace) -> None:
         == DependencyType.SUPERVISOR
     ]
 
+    sentry_logger.info(
+        "Stopping service",
+        extra={
+            "service_name": service.name,
+            "exclude_local": exclude_local,
+            "active_modes": list(active_modes),
+        },
+    )
+
     with Status(
         lambda: console.warning(f"Stopping {service.name}"),
     ) as status:

devservices-1.2.3/devservices/commands/purge.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+import os
+import shutil
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+
+from devservices.configs.service_config import load_service_config_from_file
+from devservices.constants import DEPENDENCY_CONFIG_VERSION
+from devservices.constants import DEVSERVICES_CACHE_DIR
+from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR
+from devservices.constants import DEVSERVICES_ORCHESTRATOR_LABEL
+from devservices.constants import DOCKER_NETWORK_NAME
+from devservices.exceptions import ConfigNotFoundError
+from devservices.exceptions import ConfigParseError
+from devservices.exceptions import ConfigValidationError
+from devservices.exceptions import DockerDaemonNotRunningError
+from devservices.exceptions import DockerError
+from devservices.utils.console import Console
+from devservices.utils.console import Status
+from devservices.utils.docker import get_matching_containers
+from devservices.utils.docker import get_matching_networks
+from devservices.utils.docker import get_volumes_for_containers
+from devservices.utils.docker import remove_docker_resources
+from devservices.utils.docker import stop_containers
+from devservices.utils.state import State
+from devservices.utils.state import StateTables
+
+
+def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
+    parser = subparsers.add_parser("purge", help="Purge the local devservices cache")
+    parser.add_argument(
+        "service_name",
+        nargs="?",
+        help="Service name to purge (optional, purges all if not specified)",
+        default=None,
+    )
+    parser.set_defaults(func=purge)
+
+
+def _get_service_cache_paths(service_name: str) -> list[str]:
+    """Find cache directory paths for a given service name."""
+
+    cache_paths: list[str] = []
+    dependencies_cache_dir = os.path.join(
+        DEVSERVICES_DEPENDENCIES_CACHE_DIR, DEPENDENCY_CONFIG_VERSION
+    )
+
+    if not os.path.exists(dependencies_cache_dir):
+        return cache_paths
+
+    for repo_name in os.listdir(dependencies_cache_dir):
+        repo_path = os.path.join(dependencies_cache_dir, repo_name)
+        if not os.path.isdir(repo_path):
+            continue
+
+        try:
+            service_config = load_service_config_from_file(repo_path)
+            if service_config.service_name == service_name:
+                cache_paths.append(repo_path)
+        except (ConfigNotFoundError, ConfigParseError, ConfigValidationError):
+            # Skip invalid configs
+            continue
+
+    return cache_paths
+
+
+def purge(args: Namespace) -> None:
+    """Purge the local devservices state and cache and remove all devservices containers and volumes."""
+    console = Console()
+    service_name = getattr(args, "service_name", None)
+
+    if service_name:
+        _purge_service(service_name, console)
+    else:
+        _purge_all(console)
+
+
+def _purge_service(service_name: str, console: Console) -> None:
+    """Purge a specific service."""
+    state = State()
+
+    # Warn user about potential dependency issues
+    if not console.confirm(
+        f"WARNING: Purging {service_name} may introduce issues with the dependency tree.\n"
+        "Other services that depend on this service may stop working correctly.\n"
+        "Do you want to continue?"
+    ):
+        console.info("Purge cancelled.")
+        return
+
+    state.remove_service_entry(service_name, StateTables.SERVICE_RUNTIME)
+
+    try:
+        service_containers = get_matching_containers(
+            [
+                DEVSERVICES_ORCHESTRATOR_LABEL,
+                f"com.docker.compose.service={service_name}",
+            ]
+        )
+    except DockerDaemonNotRunningError as e:
+        console.warning(str(e))
+        service_containers = []
+    except DockerError as de:
+        console.failure(f"Failed to get containers for {service_name}: {de.stderr}")
+        exit(1)
+
+    if len(service_containers) == 0:
+        console.warning(f"No containers found for {service_name}")
+    else:
+        try:
+            service_volumes = get_volumes_for_containers(service_containers)
+        except DockerError as e:
+            console.failure(f"Failed to get volumes for {service_name}: {e.stderr}")
+            exit(1)
+
+        with Status(
+            lambda: console.warning(f"Stopping {service_name} containers"),
+            lambda: console.success(f"{service_name} containers have been stopped"),
+        ):
+            try:
+                stop_containers(service_containers, should_remove=True)
+            except DockerError as e:
+                console.failure(f"Failed to stop {service_name} containers: {e.stderr}")
+                exit(1)
+
+        console.warning(f"Removing {service_name} docker volumes")
+        if len(service_volumes) == 0:
+            console.success(f"No volumes found for {service_name}")
+        else:
+            try:
+                remove_docker_resources("volume", list(service_volumes))
+                console.success(f"{service_name} volumes removed")
+            except DockerError as e:
+                console.failure(f"Failed to remove {service_name} volumes: {e.stderr}")
+
+    cache_paths = _get_service_cache_paths(service_name)
+    if cache_paths:
+        console.warning(f"Removing cache for {service_name}")
+        for cache_path in cache_paths:
+            try:
+                shutil.rmtree(cache_path)
+            except PermissionError as e:
+                console.failure(f"Failed to remove cache at {cache_path}: {e}")
+                exit(1)
+        console.success(f"Cache for {service_name} has been removed")
+    else:
+        console.success(f"No cache found for {service_name}")
+
+    console.success(f"{service_name} has been purged")
+
+
+def _purge_all(console: Console) -> None:
+    """Purge all devservices state, cache, containers, volumes, and networks."""
+    if os.path.exists(DEVSERVICES_CACHE_DIR):
+        try:
+            shutil.rmtree(DEVSERVICES_CACHE_DIR)
+        except PermissionError as e:
+            console.failure(f"Failed to purge cache: {e}")
+            exit(1)
+    state = State()
+    state.clear_state()
+
+    try:
+        devservices_containers = get_matching_containers(
+            [DEVSERVICES_ORCHESTRATOR_LABEL]
+        )
+    except DockerDaemonNotRunningError as e:
+        console.warning(str(e))
+        return
+    except DockerError as de:
+        console.failure(f"Failed to get devservices containers {de.stderr}")
+        exit(1)
+
+    try:
+        devservices_volumes = get_volumes_for_containers(devservices_containers)
+    except DockerError as e:
+        console.failure(f"Failed to get devservices volumes {e.stderr}")
+        exit(1)
+
+    with Status(
+        lambda: console.warning("Stopping all devservices containers"),
+        lambda: console.success("All devservices containers have been stopped"),
+    ):
+        try:
+            stop_containers(devservices_containers, should_remove=True)
+        except DockerError as e:
+            console.failure(f"Failed to stop devservices containers {e.stderr}")
+            exit(1)
+
+    console.warning("Removing any devservices docker volumes")
+    if len(devservices_volumes) == 0:
+        console.success("No devservices volumes found to remove")
+    else:
+        try:
+            remove_docker_resources("volume", list(devservices_volumes))
+            console.success("All devservices volumes removed")
+        except DockerError as e:
+            # We don't want to exit here since we still want to try to remove the networks
+            console.failure(f"Failed to remove devservices volumes {e.stderr}")
+
+    console.warning("Removing any devservices networks")
+    try:
+        devservices_networks = get_matching_networks(DOCKER_NETWORK_NAME)
+    except DockerError as e:
+        console.failure(f"Failed to get devservices networks {e.stderr}")
+        exit(1)
+    if len(devservices_networks) == 0:
+        console.success("No devservices networks found to remove")
+    else:
+        try:
+            remove_docker_resources("network", devservices_networks)
+            console.success("All devservices networks removed")
+        except DockerError as e:
+            console.failure(f"Failed to remove devservices networks {e.stderr}")
+            exit(1)
+
+    console.success("The local devservices cache and state has been purged")

{devservices-1.2.2 → devservices-1.2.3}/devservices/commands/up.py

@@ -8,6 +8,7 @@ from argparse import ArgumentParser
 from argparse import Namespace
 
 from sentry_sdk import capture_exception
+from sentry_sdk import logger as sentry_logger
 from sentry_sdk import set_context
 from sentry_sdk import start_span
 
@@ -94,6 +95,16 @@ def up(args: Namespace, existing_status: Status | None = None) -> None:
     mode = args.mode
     exclude_local = getattr(args, "exclude_local", False)
 
+    sentry_logger.info(
+        "Starting service",
+        extra={
+            "service_name": service.name,
+            "mode": mode,
+            "exclude_local": exclude_local,
+            "available_modes": list(modes.keys()),
+        },
+    )
+
     state = State()
 
     with Status(

{devservices-1.2.2 → devservices-1.2.3}/devservices/main.py

@@ -16,6 +16,7 @@ from sentry_sdk import set_tag
 from sentry_sdk import set_user
 from sentry_sdk import start_transaction
 from sentry_sdk.integrations.argv import ArgvIntegration
+from sentry_sdk.integrations.logging import LoggingIntegration
 from sentry_sdk.types import Event
 from sentry_sdk.types import Hint
 
@@ -79,7 +80,11 @@ if not disable_sentry:
         dsn="https://56470da7302c16e83141f62f88e46449@o1.ingest.us.sentry.io/4507946704961536",
         traces_sample_rate=1.0,
         profiles_sample_rate=1.0,
-        integrations=[ArgvIntegration()],
+        integrations=[
+            ArgvIntegration(),
+            LoggingIntegration(sentry_logs_level=logging.DEBUG),
+        ],
+        enable_logs=True,
         environment=sentry_environment,
         before_send=before_send_error,
         before_send_transaction=before_send_transaction,

{devservices-1.2.2 → devservices-1.2.3}/devservices/utils/dependencies.py

@@ -14,6 +14,7 @@ from typing import TextIO
 from typing import TypeGuard
 
 from sentry_sdk import capture_message
+from sentry_sdk import logger as sentry_logger
 from sentry_sdk import set_context
 
 from devservices.configs.service_config import Dependency
@@ -417,6 +418,16 @@ def install_dependency(dependency: RemoteConfig) -> set[InstalledRemoteDependenc
         dependency.repo_name,
     )
 
+    sentry_logger.info(
+        "Installing dependency",
+        extra={
+            "repo_name": dependency.repo_name,
+            "repo_link": dependency.repo_link,
+            "branch": dependency.branch,
+            "mode": dependency.mode,
+        },
+    )
+
     os.makedirs(DEVSERVICES_DEPENDENCIES_CACHE_DIR, exist_ok=True)
 
     # Ensure that only one process is installing a specific dependency at a time
@@ -498,6 +509,14 @@ def _update_dependency(
     dependency: RemoteConfig,
     dependency_repo_dir: str,
 ) -> None:
+    sentry_logger.info(
+        "Updating dependency",
+        extra={
+            "repo_name": dependency.repo_name,
+            "repo_link": dependency.repo_link,
+            "branch": dependency.branch,
+        },
+    )
     git_config_manager = GitConfigManager(
         dependency_repo_dir,
         DEPENDENCY_GIT_PARTIAL_CLONE_CONFIG_OPTIONS,
@@ -580,6 +599,14 @@ def _checkout_dependency(
     dependency: RemoteConfig,
     dependency_repo_dir: str,
 ) -> None:
+    sentry_logger.info(
+        "Checking out dependency",
+        extra={
+            "repo_name": dependency.repo_name,
+            "repo_link": dependency.repo_link,
+            "branch": dependency.branch,
+        },
+    )
     with tempfile.TemporaryDirectory() as temp_dir:
         try:
             _run_command(

{devservices-1.2.2 → devservices-1.2.3}/devservices/utils/docker_compose.py

@@ -12,6 +12,7 @@ from typing import cast
 from typing import NamedTuple
 
 from packaging import version
+from sentry_sdk import logger as sentry_logger
 
 from devservices.configs.service_config import load_service_config_from_file
 from devservices.constants import CONFIG_FILE_NAME
@@ -306,6 +307,14 @@ def run_cmd(
     console = Console()
     cmd_pretty = shlex.join(cmd)
 
+    sentry_logger.info(
+        "Running docker compose command",
+        extra={
+            "command": cmd_pretty,
+            "max_retries": retries,
+        },
+    )
+
     proc = None
     retries += 1  # initial try
 

{devservices-1.2.2 → devservices-1.2.3}/devservices.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devservices
-Version: 1.2.2
+Version: 1.2.3
 Requires-Python: >=3.11
 License-File: LICENSE.md
 Requires-Dist: pyyaml

{devservices-1.2.2 → devservices-1.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devservices"
-version = "1.2.2"
+version = "1.2.3"
 # 3.11 is just for internal pypi compat
 requires-python = ">=3.11"
 dependencies = [

{devservices-1.2.2 → devservices-1.2.3}/tests/commands/test_purge.py

@@ -552,3 +552,147 @@ def test_purge_with_cache_and_state_and_containers_with_networks_and_volumes(
                 mock.call("network", ["abc", "def", "ghe"]),
             ]
         )
+
+
+@mock.patch("devservices.commands.purge.Console.confirm")
+@mock.patch("devservices.commands.purge.get_matching_containers")
+@mock.patch("devservices.commands.purge.get_volumes_for_containers")
+@mock.patch("devservices.commands.purge.stop_containers")
+@mock.patch("devservices.commands.purge.remove_docker_resources")
+@mock.patch("devservices.commands.purge._get_service_cache_paths")
+def test_purge_specific_service(
+    mock_get_service_cache_paths: mock.Mock,
+    mock_remove_docker_resources: mock.Mock,
+    mock_stop_containers: mock.Mock,
+    mock_get_volumes_for_containers: mock.Mock,
+    mock_get_matching_containers: mock.Mock,
+    mock_console_confirm: mock.Mock,
+    tmp_path: Path,
+) -> None:
+    """Test that purging a specific service removes only that service's containers, volumes, and cache."""
+    mock_console_confirm.return_value = True
+    mock_get_matching_containers.return_value = [
+        "kafka-container-1",
+        "kafka-container-2",
+    ]
+    mock_get_volumes_for_containers.return_value = ["kafka-volume-1", "kafka-volume-2"]
+    cache_path = tmp_path / "dependencies" / "v1" / "kafka-repo"
+    cache_path.mkdir(parents=True, exist_ok=True)
+    mock_get_service_cache_paths.return_value = [str(cache_path)]
+
+    with (
+        mock.patch("devservices.utils.state.STATE_DB_FILE", str(tmp_path / "state")),
+        mock.patch(
+            "devservices.utils.docker.check_docker_daemon_running", return_value=None
+        ),
+    ):
+        state = State()
+        # Don't add kafka to STARTED_SERVICES - it should be stopped before purging
+        # Add redis to verify it's not affected by kafka purge
+        state.update_service_entry("redis", "default", StateTables.STARTED_SERVICES)
+
+        assert state.get_service_entries(StateTables.STARTED_SERVICES) == ["redis"]
+        assert cache_path.exists()
+
+        purge(Namespace(service_name="kafka"))
+
+        # redis should still be in state (unaffected)
+        assert state.get_service_entries(StateTables.STARTED_SERVICES) == ["redis"]
+        # Cache path should be removed
+        assert not cache_path.exists()
+
+        # Should filter containers by service name
+        mock_get_matching_containers.assert_called_once_with(
+            [
+                DEVSERVICES_ORCHESTRATOR_LABEL,
+                "com.docker.compose.service=kafka",
+            ]
+        )
+        mock_get_volumes_for_containers.assert_called_once_with(
+            ["kafka-container-1", "kafka-container-2"]
+        )
+        mock_stop_containers.assert_called_once_with(
+            ["kafka-container-1", "kafka-container-2"], should_remove=True
+        )
+        mock_remove_docker_resources.assert_called_once_with(
+            "volume", ["kafka-volume-1", "kafka-volume-2"]
+        )
+        mock_get_service_cache_paths.assert_called_once_with("kafka")
+
+
+@mock.patch("devservices.commands.purge.Console.confirm")
+@mock.patch("devservices.commands.purge.get_matching_containers")
+@mock.patch("devservices.commands.purge._get_service_cache_paths")
+def test_purge_specific_service_no_containers(
+    mock_get_service_cache_paths: mock.Mock,
+    mock_get_matching_containers: mock.Mock,
+    mock_console_confirm: mock.Mock,
+    capsys: pytest.CaptureFixture[str],
+    tmp_path: Path,
+) -> None:
+    """Test that purging a service with no containers or cache still removes it from state."""
+    mock_console_confirm.return_value = True
+    mock_get_matching_containers.return_value = []
+    mock_get_service_cache_paths.return_value = []
+
+    with (
+        mock.patch("devservices.utils.state.STATE_DB_FILE", str(tmp_path / "state")),
+        mock.patch(
+            "devservices.utils.docker.check_docker_daemon_running", return_value=None
+        ),
+    ):
+        state = State()
+        # Don't add kafka to STARTED_SERVICES - it should be stopped before purging
+
+        args = Namespace(service_name="kafka")
+        purge(args)
+
+        # State should remain empty (kafka was never added)
+        assert state.get_service_entries(StateTables.STARTED_SERVICES) == []
+
+        captured = capsys.readouterr()
+        assert "No containers found for kafka" in captured.out
+        assert "No cache found for kafka" in captured.out
+        assert "kafka has been purged" in captured.out
+
+
+@mock.patch("devservices.commands.purge.Console.confirm")
+@mock.patch("devservices.commands.purge.get_matching_containers")
+@mock.patch("devservices.commands.purge._get_service_cache_paths")
+def test_purge_specific_service_cancelled_by_user(
+    mock_get_service_cache_paths: mock.Mock,
+    mock_get_matching_containers: mock.Mock,
+    mock_console_confirm: mock.Mock,
+    capsys: pytest.CaptureFixture[str],
+    tmp_path: Path,
+) -> None:
+    """Test that purging a service can be cancelled by the user."""
+    mock_console_confirm.return_value = False
+    mock_get_matching_containers.return_value = []
+    mock_get_service_cache_paths.return_value = []
+
+    with (
+        mock.patch("devservices.utils.state.STATE_DB_FILE", str(tmp_path / "state")),
+        mock.patch(
+            "devservices.utils.docker.check_docker_daemon_running", return_value=None
+        ),
+    ):
+        state = State()
+        # Add kafka to state
+        state.update_service_entry("kafka", "default", StateTables.STARTED_SERVICES)
+
+        args = Namespace(service_name="kafka")
+        purge(args)
+
+        # Service should still be in state (purge was cancelled)
+        assert state.get_service_entries(StateTables.STARTED_SERVICES) == ["kafka"]
+
+        # Should have prompted user
+        mock_console_confirm.assert_called_once()
+
+        # Should not have attempted to get containers
+        mock_get_matching_containers.assert_not_called()
+        mock_get_service_cache_paths.assert_not_called()
+
+        captured = capsys.readouterr()
+        assert "Purge cancelled." in captured.out

devservices-1.2.2/devservices/commands/purge.py

@@ -1,96 +0,0 @@
-from __future__ import annotations
-
-import os
-import shutil
-from argparse import _SubParsersAction
-from argparse import ArgumentParser
-from argparse import Namespace
-
-from devservices.constants import DEVSERVICES_CACHE_DIR
-from devservices.constants import DEVSERVICES_ORCHESTRATOR_LABEL
-from devservices.constants import DOCKER_NETWORK_NAME
-from devservices.exceptions import DockerDaemonNotRunningError
-from devservices.exceptions import DockerError
-from devservices.utils.console import Console
-from devservices.utils.console import Status
-from devservices.utils.docker import get_matching_containers
-from devservices.utils.docker import get_matching_networks
-from devservices.utils.docker import get_volumes_for_containers
-from devservices.utils.docker import remove_docker_resources
-from devservices.utils.docker import stop_containers
-from devservices.utils.state import State
-
-
-def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
-    parser = subparsers.add_parser("purge", help="Purge the local devservices cache")
-    parser.set_defaults(func=purge)
-
-
-def purge(_args: Namespace) -> None:
-    """Purge the local devservices state and cache and remove all devservices containers and volumes."""
-    console = Console()
-
-    if os.path.exists(DEVSERVICES_CACHE_DIR):
-        try:
-            shutil.rmtree(DEVSERVICES_CACHE_DIR)
-        except PermissionError as e:
-            console.failure(f"Failed to purge cache: {e}")
-            exit(1)
-    state = State()
-    state.clear_state()
-
-    try:
-        devservices_containers = get_matching_containers(
-            [DEVSERVICES_ORCHESTRATOR_LABEL]
-        )
-    except DockerDaemonNotRunningError as e:
-        console.warning(str(e))
-        return
-    except DockerError as de:
-        console.failure(f"Failed to get devservices containers {de.stderr}")
-        exit(1)
-
-    try:
-        devservices_volumes = get_volumes_for_containers(devservices_containers)
-    except DockerError as e:
-        console.failure(f"Failed to get devservices volumes {e.stderr}")
-        exit(1)
-
-    with Status(
-        lambda: console.warning("Stopping all devservices containers"),
-        lambda: console.success("All devservices containers have been stopped"),
-    ):
-        try:
-            stop_containers(devservices_containers, should_remove=True)
-        except DockerError as e:
-            console.failure(f"Failed to stop devservices containers {e.stderr}")
-            exit(1)
-
-    console.warning("Removing any devservices docker volumes")
-    if len(devservices_volumes) == 0:
-        console.success("No devservices volumes found to remove")
-    else:
-        try:
-            remove_docker_resources("volume", list(devservices_volumes))
-            console.success("All devservices volumes removed")
-        except DockerError as e:
-            # We don't want to exit here since we still want to try to remove the networks
-            console.failure(f"Failed to remove devservices volumes {e.stderr}")
-
-    console.warning("Removing any devservices networks")
-    try:
-        devservices_networks = get_matching_networks(DOCKER_NETWORK_NAME)
-    except DockerError as e:
-        console.failure(f"Failed to get devservices networks {e.stderr}")
-        exit(1)
-    if len(devservices_networks) == 0:
-        console.success("No devservices networks found to remove")
-    else:
-        try:
-            remove_docker_resources("network", devservices_networks)
-            console.success("All devservices networks removed")
-        except DockerError as e:
-            console.failure(f"Failed to remove devservices networks {e.stderr}")
-            exit(1)
-
-    console.success("The local devservices cache and state has been purged")