devservices 1.0.3__tar.gz → 1.0.5__tar.gz

{devservices-1.0.3 → devservices-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: devservices
-Version: 1.0.3
+Version: 1.0.5
 Requires-Python: >=3.10
 License-File: LICENSE.md
 Requires-Dist: pyyaml

{devservices-1.0.3 → devservices-1.0.5}/README.md

@@ -11,7 +11,7 @@ A standalone cli tool used to manage dependencies for services. It simplifies th
 The recommended way to install devservices is through a virtualenv in the requirements.txt.
 
 ```
-devservices==1.0.3
+devservices==1.0.5
 ```
 
 

{devservices-1.0.3 → devservices-1.0.5}/devservices/commands/down.py

@@ -56,10 +56,13 @@ def down(args: Namespace) -> None:
     service_name = args.service_name
     try:
         service = find_matching_service(service_name)
-    except (ConfigError, ServiceNotFoundError) as e:
+    except ConfigError as e:
         capture_exception(e)
         console.failure(str(e))
         exit(1)
+    except ServiceNotFoundError as e:
+        console.failure(str(e))
+        exit(1)
 
     modes = service.config.modes
 
@@ -69,15 +72,20 @@ def down(args: Namespace) -> None:
         console.warning(f"{service.name} is not running")
         exit(0)
 
-    mode = state.get_mode_for_service(service.name) or "default"
-    mode_dependencies = modes[mode]
+    active_modes = state.get_active_modes_for_service(service.name)
+    mode_dependencies = set()
+    for active_mode in active_modes:
+        active_mode_dependencies = modes.get(active_mode, [])
+        mode_dependencies.update(active_mode_dependencies)
 
     with Status(
         lambda: console.warning(f"Stopping {service.name}"),
         lambda: console.success(f"{service.name} stopped"),
     ) as status:
         try:
-            remote_dependencies = install_and_verify_dependencies(service, mode=mode)
+            remote_dependencies = install_and_verify_dependencies(
+                service, modes=active_modes
+            )
         except DependencyError as de:
             capture_exception(de)
             status.failure(str(de))
@@ -86,7 +94,7 @@ def down(args: Namespace) -> None:
             service, remote_dependencies
         )
         try:
-            _down(service, remote_dependencies, mode_dependencies, status)
+            _down(service, remote_dependencies, list(mode_dependencies), status)
         except DockerComposeError as dce:
             capture_exception(dce)
             status.failure(f"Failed to stop {service.name}: {dce.stderr}")
@@ -126,7 +134,7 @@ def _down(
     ] = relative_local_dependency_directory
     docker_compose_commands = get_docker_compose_commands_to_run(
         service=service,
-        remote_dependencies=remote_dependencies,
+        remote_dependencies=list(remote_dependencies),
         current_env=current_env,
         command="down",
         options=[],

{devservices-1.0.3 → devservices-1.0.5}/devservices/commands/list_dependencies.py

@@ -32,10 +32,13 @@ def list_dependencies(args: Namespace) -> None:
 
     try:
         service = find_matching_service(service_name)
-    except (ConfigError, ServiceNotFoundError) as e:
+    except ConfigError as e:
         capture_exception(e)
         console.failure(str(e))
         exit(1)
+    except ServiceNotFoundError as e:
+        console.failure(str(e))
+        exit(1)
 
     dependencies = service.config.dependencies
 
@@ -45,4 +48,4 @@ def list_dependencies(args: Namespace) -> None:
 
     console.info(f"Dependencies of {service.name}:")
     for dependency_key, dependency_info in dependencies.items():
-        console.info("-" + dependency_key + ":" + dependency_info.description)
+        console.info("- " + dependency_key + ": " + dependency_info.description)

{devservices-1.0.3 → devservices-1.0.5}/devservices/commands/list_services.py

@@ -47,7 +47,9 @@ def list_services(args: Namespace) -> None:
 
     for service in services_to_show:
         status = "running" if service.name in running_services else "stopped"
+        active_modes = state.get_active_modes_for_service(service.name)
         console.info(f"- {service.name}")
+        console.info(f"  modes: {active_modes}")
         console.info(f"  status: {status}")
         console.info(f"  location: {service.repo_path}")
 

{devservices-1.0.3 → devservices-1.0.5}/devservices/commands/logs.py

@@ -46,10 +46,13 @@ def logs(args: Namespace) -> None:
     service_name = args.service_name
     try:
         service = find_matching_service(service_name)
-    except (ConfigError, ServiceNotFoundError) as e:
+    except ConfigError as e:
         capture_exception(e)
         console.failure(str(e))
         exit(1)
+    except ServiceNotFoundError as e:
+        console.failure(str(e))
+        exit(1)
 
     modes = service.config.modes
     # TODO: allow custom modes to be used
@@ -99,7 +102,7 @@ def _logs(
     ] = relative_local_dependency_directory
     docker_compose_commands = get_docker_compose_commands_to_run(
         service=service,
-        remote_dependencies=remote_dependencies,
+        remote_dependencies=list(remote_dependencies),
         current_env=current_env,
         command="logs",
         options=["-n", MAX_LOG_LINES],

{devservices-1.0.3 → devservices-1.0.5}/devservices/commands/status.py

@@ -81,10 +81,13 @@ def status(args: Namespace) -> None:
     service_name = args.service_name
     try:
         service = find_matching_service(service_name)
-    except (ConfigError, ServiceNotFoundError) as e:
+    except ConfigError as e:
         capture_exception(e)
         console.failure(str(e))
         exit(1)
+    except ServiceNotFoundError as e:
+        console.failure(str(e))
+        exit(1)
 
     modes = service.config.modes
     # TODO: allow custom modes to be used
@@ -137,7 +140,7 @@ def _status(
     ] = relative_local_dependency_directory
     docker_compose_commands = get_docker_compose_commands_to_run(
         service=service,
-        remote_dependencies=remote_dependencies,
+        remote_dependencies=list(remote_dependencies),
         current_env=current_env,
         command="ps",
         options=["--format", "json"],

{devservices-1.0.3 → devservices-1.0.5}/devservices/commands/up.py

@@ -21,6 +21,7 @@ from devservices.exceptions import ModeDoesNotExistError
 from devservices.exceptions import ServiceNotFoundError
 from devservices.utils.console import Console
 from devservices.utils.console import Status
+from devservices.utils.dependencies import construct_dependency_graph
 from devservices.utils.dependencies import install_and_verify_dependencies
 from devservices.utils.dependencies import InstalledRemoteDependency
 from devservices.utils.docker_compose import get_docker_compose_commands_to_run
@@ -55,22 +56,25 @@ def up(args: Namespace) -> None:
     service_name = args.service_name
     try:
         service = find_matching_service(service_name)
-    except (ConfigError, ServiceNotFoundError) as e:
+    except ConfigError as e:
         capture_exception(e)
         console.failure(str(e))
         exit(1)
+    except ServiceNotFoundError as e:
+        console.failure(str(e))
+        exit(1)
 
     modes = service.config.modes
     mode = args.mode
 
     with Status(
-        lambda: console.warning(f"Starting {service.name}"),
+        lambda: console.warning(f"Starting '{service.name}' in mode: '{mode}'"),
         lambda: console.success(f"{service.name} started"),
     ) as status:
         try:
             status.info("Retrieving dependencies")
             remote_dependencies = install_and_verify_dependencies(
-                service, force_update_dependencies=True, mode=mode
+                service, force_update_dependencies=True, modes=[mode]
             )
         except DependencyError as de:
             capture_exception(de)
@@ -79,16 +83,21 @@ def up(args: Namespace) -> None:
         except ModeDoesNotExistError as mde:
             status.failure(str(mde))
             exit(1)
+        try:
+            _create_devservices_network()
+        except subprocess.CalledProcessError:
+            # Network already exists, ignore the error
+            pass
         try:
             mode_dependencies = modes[mode]
-            _up(service, remote_dependencies, mode_dependencies, status)
+            _up(service, [mode], remote_dependencies, mode_dependencies, status)
         except DockerComposeError as dce:
             capture_exception(dce)
             status.failure(f"Failed to start {service.name}: {dce.stderr}")
             exit(1)
     # TODO: We should factor in healthchecks here before marking service as running
     state = State()
-    state.add_started_service(service.name, mode)
+    state.update_started_service(service.name, mode)
 
 
 def _bring_up_dependency(
@@ -102,6 +111,7 @@ def _bring_up_dependency(
 
 def _up(
     service: Service,
+    modes: list[str],
     remote_dependencies: set[InstalledRemoteDependency],
     mode_dependencies: list[str],
     status: Status,
@@ -119,9 +129,14 @@ def _up(
         DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY
     ] = relative_local_dependency_directory
     options = ["-d"]
+    dependency_graph = construct_dependency_graph(service, modes=modes)
+    starting_order = dependency_graph.get_starting_order()
+    sorted_remote_dependencies = sorted(
+        remote_dependencies, key=lambda dep: starting_order.index(dep.service_name)
+    )
     docker_compose_commands = get_docker_compose_commands_to_run(
         service=service,
-        remote_dependencies=remote_dependencies,
+        remote_dependencies=sorted_remote_dependencies,
         current_env=current_env,
         command="up",
         options=options,
@@ -131,3 +146,11 @@ def _up(
 
     for cmd in docker_compose_commands:
         _bring_up_dependency(cmd, current_env, status, len(options))
+
+
+def _create_devservices_network() -> None:
+    subprocess.run(
+        ["docker", "network", "create", "devservices"],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )

{devservices-1.0.3 → devservices-1.0.5}/devservices/utils/dependencies.py

@@ -5,6 +5,7 @@ import os
 import shutil
 import subprocess
 import tempfile
+from collections import deque
 from concurrent.futures import as_completed
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
@@ -14,6 +15,7 @@ from typing import TypeGuard
 from devservices.configs.service_config import Dependency
 from devservices.configs.service_config import load_service_config_from_file
 from devservices.configs.service_config import RemoteConfig
+from devservices.configs.service_config import ServiceConfig
 from devservices.constants import CONFIG_FILE_NAME
 from devservices.constants import DEPENDENCY_CONFIG_VERSION
 from devservices.constants import DEPENDENCY_GIT_PARTIAL_CLONE_CONFIG_OPTIONS
@@ -35,6 +37,62 @@ from devservices.utils.services import Service
 from devservices.utils.state import State
 
 
+class DependencyGraph:
+    def __init__(self) -> None:
+        self.graph: dict[str, set[str]] = dict()
+
+    def add_dependency(self, service_name: str) -> None:
+        if service_name not in self.graph:
+            self.graph[service_name] = set()
+
+    def add_edge(self, service_name: str, dependency_name: str) -> None:
+        # TODO: We should rename services that depend on themselves
+        if service_name == dependency_name:
+            return
+        if service_name not in self.graph:
+            self.add_dependency(service_name)
+        if dependency_name not in self.graph:
+            self.add_dependency(dependency_name)
+
+        # TODO: Should we check for cycles here?
+
+        self.graph[service_name].add(dependency_name)
+
+    def topological_sort(self) -> list[str]:
+        in_degree = {service_name: 0 for service_name in self.graph}
+
+        for service_name in self.graph.keys():
+            for dependency in self.graph[service_name]:
+                in_degree[dependency] += 1
+
+        queue = deque(
+            [
+                service_name
+                for service_name in self.graph
+                if in_degree[service_name] == 0
+            ]
+        )
+        topological_order = list()
+
+        while queue:
+            service_name = queue.popleft()
+            topological_order.append(service_name)
+
+            for dependency in self.graph[service_name]:
+                in_degree[dependency] -= 1
+                if in_degree[dependency] == 0:
+                    queue.append(dependency)
+
+        if len(topological_order) != len(self.graph):
+            # TODO: Add a better exception
+            raise ValueError("Cycle detected in the dependency graph")
+
+        return topological_order
+
+    def get_starting_order(self) -> list[str]:
+        return list(reversed(self.topological_sort()))
+
+
 @dataclass(frozen=True)
 class InstalledRemoteDependency:
     service_name: str
@@ -102,11 +160,20 @@ class GitConfigManager:
 
 
 def install_and_verify_dependencies(
-    service: Service, force_update_dependencies: bool = False, mode: str = "default"
+    service: Service,
+    force_update_dependencies: bool = False,
+    modes: list[str] | None = None,
 ) -> set[InstalledRemoteDependency]:
-    if mode not in service.config.modes:
-        raise ModeDoesNotExistError(service_name=service.name, mode=mode)
-    mode_dependencies = set(service.config.modes[mode])
+    """
+    Install and verify dependencies for a service
+    """
+    if modes is None:
+        modes = ["default"]
+    mode_dependencies = set()
+    for mode in modes:
+        if mode not in service.config.modes:
+            raise ModeDoesNotExistError(service_name=service.name, mode=mode)
+        mode_dependencies.update(service.config.modes[mode])
     matching_dependencies = [
         dependency
         for dependency_key, dependency in list(service.config.dependencies.items())
@@ -288,8 +355,18 @@ def install_dependency(dependency: RemoteConfig) -> set[InstalledRemoteDependenc
                 branch=dependency.branch,
             ) from e
 
-    nested_dependencies = list(installed_config.dependencies.values())
-    nested_remote_configs = _get_remote_configs(nested_dependencies)
+    if dependency.mode not in installed_config.modes:
+        raise ModeDoesNotExistError(
+            service_name=installed_config.service_name,
+            mode=dependency.mode,
+        )
+
+    active_nested_dependencies = [
+        nested_dependency
+        for nested_dependency_name, nested_dependency in installed_config.dependencies.items()
+        if nested_dependency_name in installed_config.modes[dependency.mode]
+    ]
+    nested_remote_configs = _get_remote_configs(active_nested_dependencies)
 
     installed_dependencies: set[InstalledRemoteDependency] = set(
         [
@@ -457,3 +534,34 @@ def _run_command(
     logger = logging.getLogger(LOGGER_NAME)
     logger.debug(f"Running command: {' '.join(cmd)} in {cwd}")
     subprocess.run(cmd, cwd=cwd, check=True, stdout=stdout, stderr=subprocess.DEVNULL)
+
+
+def get_remote_dependency_config(remote_config: RemoteConfig) -> ServiceConfig:
+    dependency_repo_dir = os.path.join(
+        DEVSERVICES_DEPENDENCIES_CACHE_DIR,
+        DEPENDENCY_CONFIG_VERSION,
+        remote_config.repo_name,
+    )
+    return load_service_config_from_file(dependency_repo_dir)
+
+
+def construct_dependency_graph(service: Service, modes: list[str]) -> DependencyGraph:
+    dependency_graph = DependencyGraph()
+
+    def _construct_dependency_graph(
+        service_config: ServiceConfig, modes: list[str]
+    ) -> None:
+        service_mode_dependencies = set()
+        for mode in modes:
+            service_mode_dependencies.update(service_config.modes.get(mode, []))
+        for dependency_name, dependency in service_config.dependencies.items():
+            # Skip the dependency if it's not in the modes (since it may not be installed and we don't care about it)
+            if dependency_name not in service_mode_dependencies:
+                continue
+            dependency_graph.add_edge(service_config.service_name, dependency_name)
+            if _has_remote_config(dependency.remote):
+                dependency_config = get_remote_dependency_config(dependency.remote)
+                _construct_dependency_graph(dependency_config, [dependency.remote.mode])
+
+    _construct_dependency_graph(service.config, modes)
+    return dependency_graph

{devservices-1.0.3 → devservices-1.0.5}/devservices/utils/devenv.py

@@ -13,7 +13,7 @@ def get_coderoot() -> str:
     config_path = os.path.join(home, ".config", "sentry-devenv", "config.ini")
     try:
         devenv_config: ConfigParser = read_config(config_path)
-        return devenv_config.get("devenv", "coderoot", fallback="")
+        return os.path.expanduser(devenv_config.get("devenv", "coderoot", fallback=""))
     except (FileNotFoundError, NoSectionError, NoOptionError):
         # TODO: Handle the case where there is no config file or the coderoot is not set
         raise Exception("Failed to read code root from config")

{devservices-1.0.3 → devservices-1.0.5}/devservices/utils/docker_compose.py

@@ -163,7 +163,7 @@ def _get_non_remote_services(
 
 def get_docker_compose_commands_to_run(
     service: Service,
-    remote_dependencies: set[InstalledRemoteDependency],
+    remote_dependencies: list[InstalledRemoteDependency],
     current_env: dict[str, str],
     command: str,
     options: list[str],
@@ -184,8 +184,7 @@ def get_docker_compose_commands_to_run(
         + sorted(list(services_to_use))  # Sort the services to prevent flaky tests
         + options
     )
-    # Sort the remote dependencies by service name to ensure a deterministic order
-    for dependency in sorted(remote_dependencies, key=lambda x: x.service_name):
+    for dependency in remote_dependencies:
         # TODO: Consider passing in service config in InstalledRemoteDependency instead of loading it here
         dependency_service_config = load_service_config_from_file(dependency.repo_path)
         dependency_config_path = os.path.join(

{devservices-1.0.3 → devservices-1.0.5}/devservices/utils/state.py

@@ -35,17 +35,26 @@ class State:
         )
         self.conn.commit()
 
-    def add_started_service(self, service_name: str, mode: str) -> None:
+    def update_started_service(self, service_name: str, mode: str) -> None:
         cursor = self.conn.cursor()
         started_services = self.get_started_services()
-        if service_name in started_services:
+        active_modes = self.get_active_modes_for_service(service_name)
+        if service_name in started_services and mode in active_modes:
             return
-        cursor.execute(
-            """
-            INSERT INTO started_services (service_name, mode) VALUES (?, ?)
-        """,
-            (service_name, mode),
-        )
+        if service_name in started_services:
+            cursor.execute(
+                """
+                UPDATE started_services SET mode = ? WHERE service_name = ?
+            """,
+                (",".join(active_modes + [mode]), service_name),
+            )
+        else:
+            cursor.execute(
+                """
+                INSERT INTO started_services (service_name, mode) VALUES (?, ?)
+            """,
+                (service_name, ",".join(active_modes + [mode])),
+            )
         self.conn.commit()
 
     def remove_started_service(self, service_name: str) -> None:
@@ -67,7 +76,7 @@ class State:
         )
         return [row[0] for row in cursor.fetchall()]
 
-    def get_mode_for_service(self, service_name: str) -> str | None:
+    def get_active_modes_for_service(self, service_name: str) -> list[str]:
         cursor = self.conn.cursor()
         cursor.execute(
             """
@@ -77,8 +86,8 @@ class State:
         )
         result = cursor.fetchone()
         if result is None:
-            return None
-        return str(result[0])
+            return []
+        return str(result[0]).split(",")
 
     def clear_state(self) -> None:
         cursor = self.conn.cursor()

{devservices-1.0.3 → devservices-1.0.5}/devservices.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: devservices
-Version: 1.0.3
+Version: 1.0.5
 Requires-Python: >=3.10
 License-File: LICENSE.md
 Requires-Dist: pyyaml

{devservices-1.0.3 → devservices-1.0.5}/devservices.egg-info/SOURCES.txt

@@ -38,9 +38,11 @@ testing/utils.py
 tests/__init__.py
 tests/conftest.py
 tests/commands/test_down.py
+tests/commands/test_list_dependencies.py
 tests/commands/test_list_services.py
 tests/commands/test_logs.py
 tests/commands/test_purge.py
+tests/commands/test_status.py
 tests/commands/test_up.py
 tests/commands/test_update.py
 tests/configs/test_service_config.py
@@ -48,4 +50,5 @@ tests/utils/test_dependencies.py
 tests/utils/test_docker.py
 tests/utils/test_docker_compose.py
 tests/utils/test_install_binary.py
+tests/utils/test_services.py
 tests/utils/test_state.py

{devservices-1.0.3 → devservices-1.0.5}/pyproject.toml

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

{devservices-1.0.3 → devservices-1.0.5}/tests/commands/test_down.py

@@ -13,6 +13,8 @@ from devservices.constants import CONFIG_FILE_NAME
 from devservices.constants import DEPENDENCY_CONFIG_VERSION
 from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY
 from devservices.constants import DEVSERVICES_DIR_NAME
+from devservices.exceptions import ConfigError
+from devservices.exceptions import ServiceNotFoundError
 from devservices.utils.state import State
 from testing.utils import create_config_file
 
@@ -64,7 +66,7 @@ def test_down_simple(
             "devservices.utils.state.STATE_DB_FILE", str(tmp_path / "state")
         ):
             state = State()
-            state.add_started_service("example-service", "default")
+            state.update_started_service("example-service", "default")
             down(args)
 
         # Ensure the DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY is set and is relative
@@ -135,7 +137,7 @@ def test_down_error(
 
     with mock.patch("devservices.utils.state.STATE_DB_FILE", str(tmp_path / "state")):
         state = State()
-        state.add_started_service("example-service", "default")
+        state.update_started_service("example-service", "default")
         with pytest.raises(SystemExit):
             down(args)
 
@@ -200,7 +202,7 @@ def test_down_mode_simple(
             "devservices.utils.state.STATE_DB_FILE", str(tmp_path / "state")
         ):
             state = State()
-            state.add_started_service("example-service", "test")
+            state.update_started_service("example-service", "test")
             down(args)
 
         # Ensure the DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY is set and is relative
@@ -231,3 +233,33 @@ def test_down_mode_simple(
 
         captured = capsys.readouterr()
         assert "Stopping redis" in captured.out.strip()
+
+
+@mock.patch("devservices.commands.down.find_matching_service")
+def test_down_config_error(
+    find_matching_service_mock: mock.Mock, capsys: pytest.CaptureFixture[str]
+) -> None:
+    find_matching_service_mock.side_effect = ConfigError("Config error")
+    args = Namespace(service_name="example-service", debug=False)
+
+    with pytest.raises(SystemExit):
+        down(args)
+
+    find_matching_service_mock.assert_called_once_with("example-service")
+    captured = capsys.readouterr()
+    assert "Config error" in captured.out.strip()
+
+
+@mock.patch("devservices.commands.down.find_matching_service")
+def test_down_service_not_found_error(
+    find_matching_service_mock: mock.Mock, capsys: pytest.CaptureFixture[str]
+) -> None:
+    find_matching_service_mock.side_effect = ServiceNotFoundError("Service not found")
+    args = Namespace(service_name="example-service", debug=False)
+
+    with pytest.raises(SystemExit):
+        down(args)
+
+    find_matching_service_mock.assert_called_once_with("example-service")
+    captured = capsys.readouterr()
+    assert "Service not found" in captured.out.strip()