devservices 0.0.5__tar.gz → 1.0.1__tar.gz

{devservices-0.0.5 → devservices-1.0.1}/PKG-INFO

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

{devservices-0.0.5 → devservices-1.0.1}/README.md

@@ -8,20 +8,13 @@ A standalone cli tool used to manage dependencies for services. It simplifies th
 
 ## Installation
 
-A system-wide installation can be done by downloading the binary of the latest release
+The recommended way to install devservices is through a virtualenv in the requirements.txt.
 
 ```
-PLATFORM=darwin # Options: darwin/linux
-INSTALL_DIR="$HOME/.local/bin"
-curl -L "https://github.com/getsentry/devservices/releases/download/0.0.5/devservices-$PLATFORM" -o "$INSTALL_DIR/devservices"
-chmod +x "$INSTALL_DIR/devservices"
+devservices==1.0.1
 ```
 
-Alternatively, if the repository you're working in has a python virtualenv, you can simply add this to the requirements-dev.txt:
 
-```
-devservices==0.0.5
-```
 ## Usage
 
 devservices provides several commands to manage your services:
@@ -36,3 +29,5 @@ NOTE: service-name is an optional parameter. If not provided, devservices will a
 - `devservices logs <service-name>`: View logs for a specific service.
 - `devservices list-services`: List all available Sentry services.
 - `devservices list-dependencies <service-name>`: List all dependencies for a service and whether they are enabled/disabled.
+- `devservices update` Update devservices to the latest version.
+- `devservices purge`: Purge the local devservices cache.

{devservices-0.0.5 → devservices-1.0.1}/devservices/commands/list_dependencies.py

@@ -4,6 +4,7 @@ from argparse import _SubParsersAction
 from argparse import ArgumentParser
 from argparse import Namespace
 
+from devservices.utils.console import Console
 from devservices.utils.services import find_matching_service
 
 
@@ -22,20 +23,21 @@ def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
 
 def list_dependencies(args: Namespace) -> None:
     """List the dependencies of a service."""
+    console = Console()
     service_name = args.service_name
 
     try:
         service = find_matching_service(service_name)
     except Exception as e:
-        print(e)
+        console.failure(str(e))
         exit(1)
 
     dependencies = service.config.dependencies
 
     if not dependencies:
-        print(f"No dependencies found for {service.name}")
+        console.info(f"No dependencies found for {service.name}")
         return
 
-    print(f"Dependencies of {service.name}:")
+    console.info(f"Dependencies of {service.name}:")
     for dependency_key, dependency_info in dependencies.items():
-        print("-", dependency_key, ":", dependency_info.description)
+        console.info("-" + dependency_key + ":" + dependency_info.description)

{devservices-0.0.5 → devservices-1.0.1}/devservices/commands/list_services.py

@@ -4,6 +4,7 @@ from argparse import _SubParsersAction
 from argparse import ArgumentParser
 from argparse import Namespace
 
+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
@@ -24,7 +25,7 @@ def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
 
 def list_services(args: Namespace) -> None:
     """List the services installed locally."""
-
+    console = Console()
     # Get all of the services installed locally
     coderoot = get_coderoot()
     services = get_local_services(coderoot)
@@ -32,7 +33,7 @@ def list_services(args: Namespace) -> None:
     running_services = state.get_started_services()
 
     if not services:
-        print("No services found")
+        console.warning("No services found")
         return
 
     services_to_show = (
@@ -40,19 +41,19 @@ def list_services(args: Namespace) -> None:
     )
 
     if args.all:
-        print("Services installed locally:")
+        console.info("Services installed locally:")
     else:
-        print("Running services:")
+        console.info("Running services:")
 
     for service in services_to_show:
         status = "running" if service.name in running_services else "stopped"
-        print(f"- {service.name}")
-        print(f"  status: {status}")
-        print(f"  location: {service.repo_path}")
+        console.info(f"- {service.name}")
+        console.info(f"  status: {status}")
+        console.info(f"  location: {service.repo_path}")
 
     if not args.all:
         stopped_count = len(services) - len(services_to_show)
         if stopped_count > 0:
-            print(
+            console.info(
                 f"\n{stopped_count} stopped service(s) not shown. Use --all/-a to see them."
             )

{devservices-0.0.5 → devservices-1.0.1}/devservices/commands/logs.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import sys
 from argparse import _SubParsersAction
 from argparse import ArgumentParser
 from argparse import Namespace
@@ -8,6 +7,8 @@ from argparse import Namespace
 from devservices.constants import MAX_LOG_LINES
 from devservices.exceptions import DependencyError
 from devservices.exceptions import DockerComposeError
+from devservices.utils.console import Console
+from devservices.utils.dependencies import install_and_verify_dependencies
 from devservices.utils.docker_compose import run_docker_compose_command
 from devservices.utils.services import find_matching_service
 from devservices.utils.state import State
@@ -26,11 +27,12 @@ def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
 
 def logs(args: Namespace) -> None:
     """View the logs for a specified service."""
+    console = Console()
     service_name = args.service_name
     try:
         service = find_matching_service(service_name)
     except Exception as e:
-        print(e)
+        console.failure(str(e))
         exit(1)
 
     modes = service.config.modes
@@ -41,19 +43,26 @@ def logs(args: Namespace) -> None:
     state = State()
     running_services = state.get_started_services()
     if service_name not in running_services:
-        print(f"Service {service_name} is not running")
+        console.warning(f"Service {service_name} is not running")
         return
 
     try:
-        logs_output = run_docker_compose_command(
-            service, "logs", mode_dependencies, options=["-n", MAX_LOG_LINES]
-        )
+        remote_dependencies = install_and_verify_dependencies(service)
     except DependencyError as de:
-        print(str(de))
+        console.failure(str(de))
         exit(1)
+    try:
+        logs_output = run_docker_compose_command(
+            service,
+            "logs",
+            mode_dependencies,
+            remote_dependencies,
+            options=["-n", MAX_LOG_LINES],
+        )
     except DockerComposeError as dce:
-        print(f"Failed to get logs for {service.name}: {dce.stderr}")
+        console.failure(f"Failed to get logs for {service.name}: {dce.stderr}")
         exit(1)
     for log in logs_output:
-        sys.stdout.write(log.stdout)
-        sys.stdout.flush()
+        log_stdout: str | None = log.stdout
+        if log_stdout is not None:
+            console.info(log_stdout)

devservices-1.0.1/devservices/commands/purge.py

@@ -0,0 +1,50 @@
+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.exceptions import DockerDaemonNotRunningError
+from devservices.utils.console import Console
+from devservices.utils.console import Status
+from devservices.utils.docker import stop_all_running_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 cache."""
+    console = Console()
+    # Prompt the user to stop all running containers
+    should_stop_containers = console.confirm(
+        "Warning: Purging stops all running containers and clears devservices state. Would you like to continue?"
+    )
+    if not should_stop_containers:
+        console.warning("Purge canceled")
+        return
+
+    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()
+    with Status(
+        lambda: console.warning("Stopping all running containers"),
+        lambda: console.success("All running containers have been stopped"),
+    ):
+        try:
+            stop_all_running_containers()
+        except DockerDaemonNotRunningError:
+            console.warning("The docker daemon not running, no containers to stop")
+
+    console.success("The local devservices cache and state has been purged")

{devservices-0.0.5 → devservices-1.0.1}/devservices/commands/start.py

@@ -6,7 +6,9 @@ from argparse import Namespace
 
 from devservices.exceptions import DependencyError
 from devservices.exceptions import DockerComposeError
+from devservices.utils.console import Console
 from devservices.utils.console import Status
+from devservices.utils.dependencies import install_and_verify_dependencies
 from devservices.utils.docker_compose import run_docker_compose_command
 from devservices.utils.services import find_matching_service
 from devservices.utils.state import State
@@ -17,16 +19,23 @@ def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
     parser.add_argument(
         "service_name", help="Name of the service to start", nargs="?", default=None
     )
+    parser.add_argument(
+        "--debug",
+        help="Enable debug mode",
+        action="store_true",
+        default=False,
+    )
     parser.set_defaults(func=start)
 
 
 def start(args: Namespace) -> None:
     """Start a service and its dependencies."""
+    console = Console()
     service_name = args.service_name
     try:
         service = find_matching_service(service_name)
     except Exception as e:
-        print(e)
+        console.failure(str(e))
         exit(1)
 
     modes = service.config.modes
@@ -34,20 +43,27 @@ def start(args: Namespace) -> None:
     mode_to_start = "default"
     mode_dependencies = modes[mode_to_start]
 
-    with Status(f"Starting {service.name}", f"{service.name} started") as status:
+    with Status(
+        lambda: console.warning(f"Starting {service.name}"),
+        lambda: console.success(f"{service.name} started"),
+    ) as status:
+        try:
+            remote_dependencies = install_and_verify_dependencies(
+                service, force_update_dependencies=True
+            )
+        except DependencyError as de:
+            status.failure(str(de))
+            exit(1)
         try:
             run_docker_compose_command(
                 service,
                 "up",
                 mode_dependencies,
-                ["-d"],
-                force_update_dependencies=True,
+                remote_dependencies,
+                options=["-d"],
             )
-        except DependencyError as de:
-            status.print(str(de))
-            exit(1)
         except DockerComposeError as dce:
-            status.print(f"Failed to start {service.name}: {dce.stderr}")
+            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()

{devservices-0.0.5 → devservices-1.0.1}/devservices/commands/status.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
 import json
-import sys
 from argparse import _SubParsersAction
 from argparse import ArgumentParser
 from argparse import Namespace
 
 from devservices.exceptions import DependencyError
 from devservices.exceptions import DockerComposeError
+from devservices.utils.console import Console
+from devservices.utils.dependencies import install_and_verify_dependencies
 from devservices.utils.docker_compose import run_docker_compose_command
 from devservices.utils.services import find_matching_service
 
@@ -61,11 +62,12 @@ def format_status_output(status_json: str) -> str:
 
 def status(args: Namespace) -> None:
     """Start a service and its dependencies."""
+    console = Console()
     service_name = args.service_name
     try:
         service = find_matching_service(service_name)
     except Exception as e:
-        print(e)
+        console.failure(str(e))
         exit(1)
 
     modes = service.config.modes
@@ -74,14 +76,20 @@ def status(args: Namespace) -> None:
     mode_dependencies = modes[mode_to_view]
 
     try:
-        status_json_results = run_docker_compose_command(
-            service, "ps", mode_dependencies, options=["--format", "json"]
-        )
+        remote_dependencies = install_and_verify_dependencies(service)
     except DependencyError as de:
-        print(str(de))
+        console.failure(str(de))
         exit(1)
+    try:
+        status_json_results = run_docker_compose_command(
+            service,
+            "ps",
+            mode_dependencies,
+            remote_dependencies,
+            options=["--format", "json"],
+        )
     except DockerComposeError as dce:
-        print(f"Failed to get status for {service.name}: {dce.stderr}")
+        console.failure(f"Failed to get status for {service.name}: {dce.stderr}")
         exit(1)
 
     # Filter out empty stdout to help us determine if the service is running
@@ -89,11 +97,10 @@ def status(args: Namespace) -> None:
         status_json for status_json in status_json_results if status_json.stdout
     ]
     if len(status_json_results) == 0:
-        print(f"{service.name} is not running")
+        console.warning(f"{service.name} is not running")
         return
     output = f"Service: {service.name}\n\n"
     for status_json in status_json_results:
         output += format_status_output(status_json.stdout)
     output += "=" * LINE_LENGTH
-    sys.stdout.write(output + "\n")
-    sys.stdout.flush()
+    console.info(output + "\n")

{devservices-0.0.5 → devservices-1.0.1}/devservices/commands/stop.py

@@ -6,7 +6,10 @@ from argparse import Namespace
 
 from devservices.exceptions import DependencyError
 from devservices.exceptions import DockerComposeError
+from devservices.utils.console import Console
 from devservices.utils.console import Status
+from devservices.utils.dependencies import get_non_shared_remote_dependencies
+from devservices.utils.dependencies import install_and_verify_dependencies
 from devservices.utils.docker_compose import run_docker_compose_command
 from devservices.utils.services import find_matching_service
 from devservices.utils.state import State
@@ -17,36 +20,57 @@ def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
     parser.add_argument(
         "service_name", help="Name of the service to stop", nargs="?", default=None
     )
+    parser.add_argument(
+        "--debug",
+        help="Enable debug mode",
+        action="store_true",
+        default=False,
+    )
     parser.set_defaults(func=stop)
 
 
 def stop(args: Namespace) -> None:
     """Stop a service and its dependencies."""
+    console = Console()
     service_name = args.service_name
     try:
         service = find_matching_service(service_name)
     except Exception as e:
-        print(e)
+        console.failure(str(e))
         exit(1)
 
     modes = service.config.modes
     # TODO: allow custom modes to be used
     mode_to_stop = "default"
     mode_dependencies = modes[mode_to_stop]
+
     state = State()
     started_services = state.get_started_services()
     if service.name not in started_services:
-        print(f"{service.name} is not running")
+        console.warning(f"{service.name} is not running")
         exit(0)
 
-    with Status(f"Stopping {service.name}", f"{service.name} stopped") as status:
+    with Status(
+        lambda: console.warning(f"Stopping {service.name}"),
+        lambda: console.success(f"{service.name} stopped"),
+    ) as status:
         try:
-            run_docker_compose_command(service, "down", mode_dependencies)
+            remote_dependencies = install_and_verify_dependencies(service)
         except DependencyError as de:
-            status.print(str(de))
+            status.failure(str(de))
             exit(1)
+        remote_dependencies = get_non_shared_remote_dependencies(
+            service, remote_dependencies
+        )
+        try:
+            run_docker_compose_command(
+                service,
+                "down",
+                mode_dependencies,
+                remote_dependencies,
+            )
         except DockerComposeError as dce:
-            status.print(f"Failed to stop {service.name}: {dce.stderr}")
+            status.failure(f"Failed to stop {service.name}: {dce.stderr}")
             exit(1)
 
     # TODO: We should factor in healthchecks here before marking service as stopped

{devservices-0.0.5 → devservices-1.0.1}/devservices/commands/update.py

@@ -11,6 +11,7 @@ from devservices.commands.check_for_update import check_for_update
 from devservices.constants import DEVSERVICES_DOWNLOAD_URL
 from devservices.exceptions import BinaryInstallError
 from devservices.exceptions import DevservicesUpdateError
+from devservices.utils.console import Console
 from devservices.utils.install_binary import install_binary
 
 
@@ -21,14 +22,16 @@ def is_in_virtualenv() -> bool:
 
 
 def update_version(exec_path: str, latest_version: str) -> None:
+    console = Console()
     system = platform.system().lower()
     url = f"{DEVSERVICES_DOWNLOAD_URL}/{latest_version}/devservices-{system}"
     try:
         install_binary("devservices", exec_path, latest_version, url)
     except BinaryInstallError as e:
-        raise DevservicesUpdateError(f"Failed to update devservices: {e}")
+        console.failure(f"Failed to update devservices: {e}")
+        exit(1)
 
-    print(f"Devservices {latest_version} updated successfully")
+    console.success(f"Devservices {latest_version} updated successfully")
 
 
 def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
@@ -39,6 +42,7 @@ def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
 
 
 def update(args: Namespace) -> None:
+    console = Console()
     current_version = metadata.version("devservices")
     latest_version = check_for_update(current_version)
 
@@ -46,21 +50,21 @@ def update(args: Namespace) -> None:
         raise DevservicesUpdateError("Failed to check for updates.")
 
     if latest_version == current_version:
-        print("You're already on the latest version.")
+        console.warning("You're already on the latest version.")
         return
 
-    print(f"A new version of devservices is available: {latest_version}")
+    console.warning(f"A new version of devservices is available: {latest_version}")
 
     if is_in_virtualenv():
-        print("You are running in a virtual environment.")
-        print(
+        console.warning("You are running in a virtual environment.")
+        console.warning(
             "To update, please update your requirements.txt or requirements-dev.txt file with the new version."
         )
-        print(
+        console.warning(
             f"For example, update the line in requirements.txt to: devservices=={latest_version}"
         )
-        print("Then, run: pip install --update -r requirements.txt")
+        console.warning("Then, run: pip install --update -r requirements.txt")
         return
 
-    print("Upgrading to the latest version...")
+    console.info("Upgrading to the latest version...")
     update_version(sys.executable, latest_version)

{devservices-0.0.5 → devservices-1.0.1}/devservices/constants.py

@@ -24,3 +24,4 @@ DOCKER_COMPOSE_DOWNLOAD_URL = "https://github.com/docker/compose/releases/downlo
 DEVSERVICES_DOWNLOAD_URL = "https://github.com/getsentry/devservices/releases/download"
 BINARY_PERMISSIONS = 0o755
 MAX_LOG_LINES = "100"
+LOGGER_NAME = "devservices"

{devservices-0.0.5 → devservices-1.0.1}/devservices/exceptions.py

@@ -46,7 +46,9 @@ class DevservicesUpdateError(BinaryInstallError):
 class DockerDaemonNotRunningError(Exception):
     """Raised when the Docker daemon is not running."""
 
-    pass
+    def __str__(self) -> str:
+        # TODO: Provide explicit instructions on what to do
+        return "Unable to connect to the docker daemon. Is the docker daemon running?"
 
 
 class DockerComposeInstallationError(BinaryInstallError):

{devservices-0.0.5 → devservices-1.0.1}/devservices/main.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import argparse
 import atexit
+import logging
 import os
 from importlib import metadata
 
@@ -17,8 +18,10 @@ from devservices.commands import status
 from devservices.commands import stop
 from devservices.commands import update
 from devservices.commands.check_for_update import check_for_update
+from devservices.constants import LOGGER_NAME
 from devservices.exceptions import DockerComposeInstallationError
 from devservices.exceptions import DockerDaemonNotRunningError
+from devservices.utils.console import Console
 from devservices.utils.docker_compose import check_docker_compose_version
 
 sentry_environment = (
@@ -26,6 +29,7 @@ sentry_environment = (
 )
 
 disable_sentry = os.environ.get("DISABLE_SENTRY", default=False)
+logging.basicConfig(level=logging.INFO)
 
 if not disable_sentry:
     sentry_sdk.init(
@@ -44,13 +48,14 @@ def cleanup() -> None:
 
 
 def main() -> None:
+    console = Console()
     try:
         check_docker_compose_version()
     except DockerDaemonNotRunningError as e:
-        print(e)
+        console.failure(str(e))
         exit(1)
     except DockerComposeInstallationError:
-        print("Failed to ensure docker compose is installed and up-to-date")
+        console.failure("Failed to ensure docker compose is installed and up-to-date")
         exit(1)
     parser = argparse.ArgumentParser(
         prog="devservices",
@@ -75,6 +80,11 @@ def main() -> None:
 
     args = parser.parse_args()
 
+    # If the command has a debug flag, set the logger to debug
+    if "debug" in args and args.debug:
+        logger = logging.getLogger(LOGGER_NAME)
+        logger.setLevel(logging.DEBUG)
+
     if args.command:
         # Call the appropriate function based on the command
         with sentry_sdk.start_transaction(op="command", name=args.command):
@@ -85,10 +95,10 @@ def main() -> None:
     if args.command != "update":
         newest_version = check_for_update(metadata.version("devservices"))
         if newest_version != metadata.version("devservices"):
-            print(
-                f"\n\033[93mWARNING: A new version of devservices is available: {newest_version}\033[0m"
+            console.warning(
+                f"WARNING: A new version of devservices is available: {newest_version}"
             )
-            print("To update, run: \033[1mdevservices update\033[0m")
+            console.warning('To update, run: "devservices update"')
 
 
 if __name__ == "__main__":