devservices 1.0.9__tar.gz → 1.0.10__tar.gz

{devservices-1.0.9 → devservices-1.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: devservices
-Version: 1.0.9
+Version: 1.0.10
 Requires-Python: >=3.10
 License-File: LICENSE.md
 Requires-Dist: pyyaml

{devservices-1.0.9 → devservices-1.0.10}/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.9
+devservices==1.0.10
 ```
 
 

{devservices-1.0.9 → devservices-1.0.10}/devservices/commands/down.py

@@ -31,6 +31,7 @@ from devservices.utils.docker_compose import run_cmd
 from devservices.utils.services import find_matching_service
 from devservices.utils.services import Service
 from devservices.utils.state import State
+from devservices.utils.state import StateTables
 
 
 def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
@@ -75,12 +76,20 @@ def down(args: Namespace) -> None:
     modes = service.config.modes
 
     state = State()
-    started_services = state.get_started_services()
-    if service.name not in started_services:
+    starting_services = set(state.get_service_entries(StateTables.STARTING_SERVICES))
+    started_services = set(state.get_service_entries(StateTables.STARTED_SERVICES))
+    active_services = starting_services.union(started_services)
+    if service.name not in active_services:
         console.warning(f"{service.name} is not running")
         exit(0)
 
-    active_modes = state.get_active_modes_for_service(service.name)
+    active_starting_modes = state.get_active_modes_for_service(
+        service.name, StateTables.STARTING_SERVICES
+    )
+    active_started_modes = state.get_active_modes_for_service(
+        service.name, StateTables.STARTED_SERVICES
+    )
+    active_modes = active_starting_modes or active_started_modes
     mode_dependencies = set()
     for active_mode in active_modes:
         active_mode_dependencies = modes.get(active_mode, [])
@@ -95,7 +104,9 @@ def down(args: Namespace) -> None:
             )
         except DependencyError as de:
             capture_exception(de)
-            status.failure(str(de))
+            status.failure(
+                f"{str(de)}. If this error persists, try running `devservices purge`"
+            )
             exit(1)
         try:
             remote_dependencies = get_non_shared_remote_dependencies(
@@ -103,17 +114,26 @@ def down(args: Namespace) -> None:
             )
         except DependencyError as de:
             capture_exception(de)
-            status.failure(str(de))
+            status.failure(
+                f"{str(de)}. If this error persists, try running `devservices purge`"
+            )
             exit(1)
 
         # Check if any service depends on the service we are trying to bring down
         # TODO: We should also take into account the active modes of the other services (this is not trivial to do)
-        other_started_services = set(started_services).difference({service.name})
+        other_started_services = active_services.difference({service.name})
         dependent_service_name = None
         for other_started_service in other_started_services:
             other_service = find_matching_service(other_started_service)
-            other_service_active_modes = state.get_active_modes_for_service(
-                other_service.name
+            other_service_active_starting_modes = state.get_active_modes_for_service(
+                other_service.name, StateTables.STARTING_SERVICES
+            )
+            other_service_active_started_modes = state.get_active_modes_for_service(
+                other_service.name, StateTables.STARTED_SERVICES
+            )
+            other_service_active_modes = (
+                other_service_active_starting_modes
+                or other_service_active_started_modes
             )
             dependency_graph = construct_dependency_graph(
                 other_service, other_service_active_modes
@@ -137,8 +157,8 @@ def down(args: Namespace) -> None:
             )
 
     # TODO: We should factor in healthchecks here before marking service as not running
-    state = State()
-    state.remove_started_service(service.name)
+    state.remove_service_entry(service.name, StateTables.STARTING_SERVICES)
+    state.remove_service_entry(service.name, StateTables.STARTED_SERVICES)
     if dependent_service_name is None:
         console.success(f"{service.name} stopped")
 

{devservices-1.0.9 → devservices-1.0.10}/devservices/commands/list_services.py

@@ -8,6 +8,7 @@ from devservices.utils.console import Console
 from devservices.utils.devenv import get_coderoot
 from devservices.utils.services import get_local_services
 from devservices.utils.state import State
+from devservices.utils.state import StateTables
 
 
 def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
@@ -30,7 +31,9 @@ def list_services(args: Namespace) -> None:
     coderoot = get_coderoot()
     services = get_local_services(coderoot)
     state = State()
-    running_services = state.get_started_services()
+    starting_services = set(state.get_service_entries(StateTables.STARTING_SERVICES))
+    started_services = set(state.get_service_entries(StateTables.STARTED_SERVICES))
+    running_services = starting_services.union(started_services)
 
     if not services:
         console.warning("No services found")
@@ -46,8 +49,18 @@ def list_services(args: Namespace) -> None:
         console.info("Running services:")
 
     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)
+        status = "stopped"
+        if service.name in starting_services:
+            status = "starting"
+        elif service.name in started_services:
+            status = "started"
+        active_starting_modes = state.get_active_modes_for_service(
+            service.name, StateTables.STARTING_SERVICES
+        )
+        active_started_modes = state.get_active_modes_for_service(
+            service.name, StateTables.STARTED_SERVICES
+        )
+        active_modes = active_starting_modes or active_started_modes
         console.info(f"- {service.name}")
         console.info(f"  modes: {active_modes}")
         console.info(f"  status: {status}")

{devservices-1.0.9 → devservices-1.0.10}/devservices/commands/logs.py

@@ -28,6 +28,7 @@ from devservices.utils.docker_compose import run_cmd
 from devservices.utils.services import find_matching_service
 from devservices.utils.services import Service
 from devservices.utils.state import State
+from devservices.utils.state import StateTables
 
 
 def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
@@ -67,7 +68,9 @@ def logs(args: Namespace) -> None:
     mode_dependencies = modes[mode_to_use]
 
     state = State()
-    running_services = state.get_started_services()
+    starting_services = set(state.get_service_entries(StateTables.STARTING_SERVICES))
+    started_services = set(state.get_service_entries(StateTables.STARTED_SERVICES))
+    running_services = starting_services.union(started_services)
     if service.name not in running_services:
         console.warning(f"Service {service.name} is not running")
         return
@@ -76,7 +79,9 @@ def logs(args: Namespace) -> None:
         remote_dependencies = install_and_verify_dependencies(service)
     except DependencyError as de:
         capture_exception(de)
-        console.failure(str(de))
+        console.failure(
+            f"{str(de)}. If this error persists, try running `devservices purge`"
+        )
         exit(1)
     try:
         logs_output = _logs(service, remote_dependencies, mode_dependencies)

{devservices-1.0.9 → devservices-1.0.10}/devservices/commands/status.py

@@ -110,7 +110,9 @@ def status(args: Namespace) -> None:
         remote_dependencies = install_and_verify_dependencies(service)
     except DependencyError as de:
         capture_exception(de)
-        console.failure(str(de))
+        console.failure(
+            f"{str(de)}. If this error persists, try running `devservices purge`"
+        )
         exit(1)
     try:
         status_json_results = _status(service, remote_dependencies, mode_dependencies)

{devservices-1.0.9 → devservices-1.0.10}/devservices/commands/up.py

@@ -34,6 +34,7 @@ from devservices.utils.docker_compose import run_cmd
 from devservices.utils.services import find_matching_service
 from devservices.utils.services import Service
 from devservices.utils.state import State
+from devservices.utils.state import StateTables
 
 
 def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
@@ -78,6 +79,8 @@ def up(args: Namespace) -> None:
     modes = service.config.modes
     mode = args.mode
 
+    state = State()
+
     with Status(
         lambda: console.warning(f"Starting '{service.name}' in mode: '{mode}'"),
         lambda: console.success(f"{service.name} started"),
@@ -89,7 +92,9 @@ def up(args: Namespace) -> None:
             )
         except DependencyError as de:
             capture_exception(de)
-            status.failure(str(de))
+            status.failure(
+                f"{str(de)}. If this error persists, try running `devservices purge`"
+            )
             exit(1)
         except ModeDoesNotExistError as mde:
             status.failure(str(mde))
@@ -99,6 +104,8 @@ def up(args: Namespace) -> None:
         except subprocess.CalledProcessError:
             # Network already exists, ignore the error
             pass
+        # Add the service to the starting services table
+        state.update_service_entry(service.name, mode, StateTables.STARTING_SERVICES)
         try:
             mode_dependencies = modes[mode]
             _up(service, [mode], remote_dependencies, mode_dependencies, status)
@@ -107,8 +114,8 @@ def up(args: Namespace) -> None:
             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.update_started_service(service.name, mode)
+    state.remove_service_entry(service.name, StateTables.STARTING_SERVICES)
+    state.update_service_entry(service.name, mode, StateTables.STARTED_SERVICES)
 
 
 def _bring_up_dependency(

{devservices-1.0.9 → devservices-1.0.10}/devservices/exceptions.py

@@ -70,27 +70,33 @@ class DockerError(Exception):
 class DockerComposeError(DockerError):
     """Base class for Docker Compose related errors."""
 
-    pass
+    def __str__(self) -> str:
+        return f"DockerComposeError: {self.command} returned {self.returncode} error: {self.stderr}"
 
 
 class ModeDoesNotExistError(Exception):
     """Raised when a mode does not exist."""
 
-    def __init__(self, service_name: str, mode: str):
+    def __init__(self, service_name: str, mode: str, available_modes: list[str]):
         self.service_name = service_name
         self.mode = mode
+        self.available_modes = available_modes
 
     def __str__(self) -> str:
-        return f"ModeDoesNotExistError: Mode '{self.mode}' does not exist for service '{self.service_name}'"
+        # All valid services should have at least one mode, so we don't check for an empty list
+        return f"ModeDoesNotExistError: Mode '{self.mode}' does not exist for service '{self.service_name}'.\nAvailable modes: {', '.join(self.available_modes)}"
 
 
 class DependencyError(Exception):
     """Base class for dependency-related errors."""
 
-    def __init__(self, repo_name: str, repo_link: str, branch: str):
+    def __init__(
+        self, repo_name: str, repo_link: str, branch: str, stderr: str | None = None
+    ):
         self.repo_name = repo_name
         self.repo_link = repo_link
         self.branch = branch
+        self.stderr = stderr
 
     def __str__(self) -> str:
         return f"DependencyError: {self.repo_name} ({self.repo_link}) on {self.branch}"

{devservices-1.0.9 → devservices-1.0.10}/devservices/utils/dependencies.py

@@ -13,6 +13,7 @@ from dataclasses import dataclass
 from typing import TextIO
 from typing import TypeGuard
 
+from sentry_sdk import capture_message
 from sentry_sdk import set_context
 
 from devservices.configs.service_config import Dependency
@@ -38,6 +39,7 @@ from devservices.utils.file_lock import lock
 from devservices.utils.services import find_matching_service
 from devservices.utils.services import Service
 from devservices.utils.state import State
+from devservices.utils.state import StateTables
 
 RELEVANT_GIT_CONFIG_KEYS = [
     "init.defaultbranch",
@@ -208,7 +210,11 @@ def install_and_verify_dependencies(
     mode_dependencies = set()
     for mode in modes:
         if mode not in service.config.modes:
-            raise ModeDoesNotExistError(service_name=service.name, mode=mode)
+            raise ModeDoesNotExistError(
+                service_name=service.name,
+                mode=mode,
+                available_modes=list(service.config.modes.keys()),
+            )
         mode_dependencies.update(service.config.modes[mode])
     matching_dependencies = [
         dependency
@@ -261,12 +267,14 @@ def get_non_shared_remote_dependencies(
     service_to_stop: Service, remote_dependencies: set[InstalledRemoteDependency]
 ) -> set[InstalledRemoteDependency]:
     state = State()
-    started_services = state.get_started_services()
+    starting_services = set(state.get_service_entries(StateTables.STARTING_SERVICES))
+    started_services = set(state.get_service_entries(StateTables.STARTED_SERVICES))
+    active_services = starting_services.union(started_services)
     # We don't care about the remote dependencies of the service we are stopping
-    started_services.remove(service_to_stop.name)
+    active_services.remove(service_to_stop.name)
     other_running_remote_dependencies: set[InstalledRemoteDependency] = set()
     base_running_service_names: set[str] = set()
-    for started_service_name in started_services:
+    for started_service_name in active_services:
         started_service = find_matching_service(started_service_name)
         for dependency_name in service_to_stop.config.dependencies.keys():
             if dependency_name == started_service.config.service_name:
@@ -408,6 +416,7 @@ def install_dependency(dependency: RemoteConfig) -> set[InstalledRemoteDependenc
         raise ModeDoesNotExistError(
             service_name=installed_config.service_name,
             mode=dependency.mode,
+            available_modes=list(installed_config.modes.keys()),
         )
 
     active_nested_dependencies = [
@@ -473,27 +482,49 @@ def _update_dependency(
             repo_name=dependency.repo_name,
             repo_link=dependency.repo_link,
             branch=dependency.branch,
+            stderr=e.stderr,
         ) from e
 
     # Check if the local repo is up-to-date
-    local_commit = subprocess.check_output(
-        ["git", "rev-parse", "HEAD"],
-        cwd=dependency_repo_dir,
-        stderr=subprocess.PIPE,
-    ).strip()
-
-    remote_commit = subprocess.check_output(
-        ["git", "rev-parse", "FETCH_HEAD"],
-        cwd=dependency_repo_dir,
-        stderr=subprocess.PIPE,
-    ).strip()
+    try:
+        local_commit = _rev_parse(dependency_repo_dir, "HEAD")
+    except subprocess.CalledProcessError as e:
+        raise DependencyError(
+            repo_name=dependency.repo_name,
+            repo_link=dependency.repo_link,
+            branch=dependency.branch,
+            stderr=e.stderr,
+        ) from e
+
+    try:
+        remote_commit = _rev_parse(dependency_repo_dir, "FETCH_HEAD")
+    except subprocess.CalledProcessError as e:
+        raise DependencyError(
+            repo_name=dependency.repo_name,
+            repo_link=dependency.repo_link,
+            branch=dependency.branch,
+            stderr=e.stderr,
+        ) from e
 
     if local_commit == remote_commit:
         # Already up-to-date, don't pull anything
+        logger = logging.getLogger(LOGGER_NAME)
+        logger.debug(
+            "Dependency %s is already up-to-date, not pulling anything",
+            dependency.repo_name,
+        )
         return
 
     # If it's not up-to-date, checkout the latest changes (forcibly)
-    _run_command(["git", "checkout", "-f", "FETCH_HEAD"], cwd=dependency_repo_dir)
+    try:
+        _run_command(["git", "checkout", "-f", "FETCH_HEAD"], cwd=dependency_repo_dir)
+    except subprocess.CalledProcessError as e:
+        raise DependencyError(
+            repo_name=dependency.repo_name,
+            repo_link=dependency.repo_link,
+            branch=dependency.branch,
+            stderr=e.stderr,
+        ) from e
 
 
 def _checkout_dependency(
@@ -518,6 +549,7 @@ def _checkout_dependency(
                 repo_name=dependency.repo_name,
                 repo_link=dependency.repo_link,
                 branch=dependency.branch,
+                stderr=e.stderr,
             ) from e
 
         # Setup config for partial clone and sparse checkout
@@ -535,10 +567,18 @@ def _checkout_dependency(
                 branch=dependency.branch,
             ) from e
 
-        _run_command(
-            ["git", "checkout", dependency.branch],
-            cwd=temp_dir,
-        )
+        try:
+            _run_command(
+                ["git", "checkout", dependency.branch],
+                cwd=temp_dir,
+            )
+        except subprocess.CalledProcessError as e:
+            raise DependencyError(
+                repo_name=dependency.repo_name,
+                repo_link=dependency.repo_link,
+                branch=dependency.branch,
+                stderr=e.stderr,
+            ) from e
 
         # Clean up the existing directory if it exists
         if os.path.exists(dependency_repo_dir):
@@ -580,12 +620,26 @@ def _has_remote_config(remote_config: RemoteConfig | None) -> TypeGuard[RemoteCo
     return remote_config is not None
 
 
+def _rev_parse(repo_dir: str, ref: str) -> str:
+    logger = logging.getLogger(LOGGER_NAME)
+    logger.debug("Parsing revision for %s (%s)", ref, repo_dir)
+    rev = (
+        subprocess.check_output(
+            ["git", "rev-parse", ref], cwd=repo_dir, stderr=subprocess.PIPE
+        )
+        .strip()
+        .decode()
+    )
+    logger.debug("Parsed revision %s for %s (%s)", rev, ref, repo_dir)
+    return rev
+
+
 def _run_command(
     cmd: list[str], cwd: str, stdout: int | TextIO | None = subprocess.DEVNULL
 ) -> None:
     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)
+    logger.debug("Running command: %s in %s", " ".join(cmd), cwd)
+    subprocess.run(cmd, cwd=cwd, check=True, stdout=stdout, stderr=subprocess.PIPE)
 
 
 def _run_command_with_retries(
@@ -601,7 +655,13 @@ def _run_command_with_retries(
             break
         except subprocess.CalledProcessError as e:
             logger = logging.getLogger(LOGGER_NAME)
-            logger.exception("Attempt %s of %s failed: %s", i + 1, retries, e)
+            logger.debug(
+                "Attempt %s of %s for %s failed: %s", i + 1, retries, cmd, e.stderr
+            )
+            capture_message(
+                f"Attempt {i + 1} of {retries} for {cmd} failed: {e.stderr}",
+                level="warning",
+            )
             if i == retries - 1:
                 raise e
             time.sleep(backoff**i)

{devservices-1.0.9 → devservices-1.0.10}/devservices/utils/docker_compose.py

@@ -270,7 +270,7 @@ def get_docker_compose_commands_to_run(
 def run_cmd(cmd: list[str], env: dict[str, str]) -> subprocess.CompletedProcess[str]:
     logger = logging.getLogger(LOGGER_NAME)
     try:
-        logger.debug(f"Running command: {' '.join(cmd)}")
+        logger.debug("Running command: %s", " ".join(cmd))
         return subprocess.run(cmd, check=True, capture_output=True, text=True, env=env)
     except subprocess.CalledProcessError as e:
         raise DockerComposeError(

{devservices-1.0.9 → devservices-1.0.10}/devservices/utils/state.py

@@ -2,11 +2,17 @@ from __future__ import annotations
 
 import os
 import sqlite3
+from enum import Enum
 
 from devservices.constants import DEVSERVICES_LOCAL_DIR
 from devservices.constants import STATE_DB_FILE
 
 
+class StateTables(Enum):
+    STARTED_SERVICES = "started_services"
+    STARTING_SERVICES = "starting_services"
+
+
 class State:
     _instance: State | None = None
     state_db_file: str
@@ -24,9 +30,20 @@ class State:
 
     def initialize_database(self) -> None:
         cursor = self.conn.cursor()
+        # Formatted strings here and throughout the fileshould be extremely low risk given these are constants
         cursor.execute(
-            """
-            CREATE TABLE IF NOT EXISTS started_services (
+            f"""
+            CREATE TABLE IF NOT EXISTS {StateTables.STARTED_SERVICES.value} (
+                service_name TEXT PRIMARY KEY,
+                mode TEXT,
+                timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """
+        )
+
+        cursor.execute(
+            f"""
+            CREATE TABLE IF NOT EXISTS {StateTables.STARTING_SERVICES.value} (
                 service_name TEXT PRIMARY KEY,
                 mode TEXT,
                 timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
@@ -35,52 +52,56 @@ class State:
         )
         self.conn.commit()
 
-    def update_started_service(self, service_name: str, mode: str) -> None:
+    def update_service_entry(
+        self, service_name: str, mode: str, table: StateTables
+    ) -> None:
         cursor = self.conn.cursor()
-        started_services = self.get_started_services()
-        active_modes = self.get_active_modes_for_service(service_name)
-        if service_name in started_services and mode in active_modes:
+        service_entries = self.get_service_entries(table)
+        active_modes = self.get_active_modes_for_service(service_name, table)
+        if service_name in service_entries and mode in active_modes:
             return
-        if service_name in started_services:
+        if service_name in service_entries:
             cursor.execute(
-                """
-                UPDATE started_services SET mode = ? WHERE service_name = ?
+                f"""
+                UPDATE {table.value} SET mode = ? WHERE service_name = ?
             """,
                 (",".join(active_modes + [mode]), service_name),
             )
         else:
             cursor.execute(
-                """
-                INSERT INTO started_services (service_name, mode) VALUES (?, ?)
+                f"""
+                INSERT INTO {table.value} (service_name, mode) VALUES (?, ?)
             """,
                 (service_name, ",".join(active_modes + [mode])),
             )
         self.conn.commit()
 
-    def remove_started_service(self, service_name: str) -> None:
+    def remove_service_entry(self, service_name: str, table: StateTables) -> None:
         cursor = self.conn.cursor()
         cursor.execute(
-            """
-            DELETE FROM started_services WHERE service_name = ?
+            f"""
+            DELETE FROM {table.value} WHERE service_name = ?
         """,
             (service_name,),
         )
         self.conn.commit()
 
-    def get_started_services(self) -> list[str]:
+    def get_service_entries(self, table: StateTables) -> list[str]:
         cursor = self.conn.cursor()
         cursor.execute(
-            """
-            SELECT service_name FROM started_services
+            f"""
+            SELECT service_name FROM {table.value}
         """
         )
         return [row[0] for row in cursor.fetchall()]
 
-    def get_active_modes_for_service(self, service_name: str) -> list[str]:
+    def get_active_modes_for_service(
+        self, service_name: str, table: StateTables
+    ) -> list[str]:
         cursor = self.conn.cursor()
         cursor.execute(
-            """
-            SELECT mode FROM started_services WHERE service_name = ?
+            f"""
+            SELECT mode FROM {table.value} WHERE service_name = ?
         """,
             (service_name,),
         )
@@ -92,8 +113,13 @@ class State:
     def clear_state(self) -> None:
         cursor = self.conn.cursor()
         cursor.execute(
-            """
-            DELETE FROM started_services
+            f"""
+            DELETE FROM {StateTables.STARTED_SERVICES.value}
+        """
+        )
+        cursor.execute(
+            f"""
+            DELETE FROM {StateTables.STARTING_SERVICES.value}
         """
         )
         self.conn.commit()

{devservices-1.0.9 → devservices-1.0.10}/devservices.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: devservices
-Version: 1.0.9
+Version: 1.0.10
 Requires-Python: >=3.10
 License-File: LICENSE.md
 Requires-Dist: pyyaml

{devservices-1.0.9 → devservices-1.0.10}/pyproject.toml

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