devservices 0.0.4__tar.gz → 1.0.0__tar.gz

{devservices-0.0.4 → devservices-1.0.0}/PKG-INFO

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

{devservices-0.0.4 → devservices-1.0.0}/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.4/devservices-$PLATFORM" -o "$INSTALL_DIR/devservices"
-chmod +x "$INSTALL_DIR/devservices"
+devservices==1.0.0
 ```
 
-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.4
-```
 ## 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.4 → devservices-1.0.0}/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.4 → devservices-1.0.0}/devservices/commands/list_services.py

@@ -4,9 +4,10 @@ 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.docker_compose import get_active_docker_compose_projects
 from devservices.utils.services import get_local_services
+from devservices.utils.state import State
 
 
 def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
@@ -24,34 +25,35 @@ 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)
-    running_projects = get_active_docker_compose_projects()
+    state = State()
+    running_services = state.get_started_services()
 
     if not services:
-        print("No services found")
+        console.warning("No services found")
         return
 
     services_to_show = (
-        services if args.all else [s for s in services if s.name in running_projects]
+        services if args.all else [s for s in services if s.name in running_services]
     )
 
     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_projects else "stopped"
-        print(f"- {service.name}")
-        print(f"  status: {status}")
-        print(f"  location: {service.repo_path}")
+        status = "running" if service.name in running_services else "stopped"
+        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-1.0.0/devservices/commands/logs.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+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
+
+
+def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
+    parser = subparsers.add_parser("logs", help="View logs for a service")
+    parser.add_argument(
+        "service_name",
+        help="Name of the service to view logs for",
+        nargs="?",
+        default=None,
+    )
+    parser.set_defaults(func=logs)
+
+
+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:
+        console.failure(str(e))
+        exit(1)
+
+    modes = service.config.modes
+    # TODO: allow custom modes to be used
+    mode_to_use = "default"
+    mode_dependencies = modes[mode_to_use]
+
+    state = State()
+    running_services = state.get_started_services()
+    if service_name not in running_services:
+        console.warning(f"Service {service_name} is not running")
+        return
+
+    try:
+        remote_dependencies = install_and_verify_dependencies(service)
+    except DependencyError as 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:
+        console.failure(f"Failed to get logs for {service.name}: {dce.stderr}")
+        exit(1)
+    for log in logs_output:
+        log_stdout: str | None = log.stdout
+        if log_stdout is not None:
+            console.info(log_stdout)

devservices-1.0.0/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.4 → devservices-1.0.0}/devservices/commands/start.py

@@ -4,10 +4,14 @@ 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.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
 
 
 def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
@@ -15,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
@@ -32,11 +43,28 @@ 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
+                service,
+                "up",
+                mode_dependencies,
+                remote_dependencies,
+                options=["-d"],
             )
         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()
+    state.add_started_service(service.name, mode_to_start)

{devservices-0.0.4 → devservices-1.0.0}/devservices/commands/status.py

@@ -1,12 +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
 
@@ -33,11 +35,13 @@ def format_status_output(status_json: str) -> str:
         service = json.loads(service_status)
         name = service["Service"]
         state = service["State"]
+        container_name = service["Name"]
         health = service.get("Health", "N/A")
         ports = service.get("Publishers", [])
         running_for = service.get("RunningFor", "N/A")
 
         output.append(f"{name}")
+        output.append(f"Container: {container_name}")
         output.append(f"Status: {state}")
         output.append(f"Health: {health}")
         output.append(f"Uptime: {running_for}")
@@ -58,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
@@ -71,19 +76,31 @@ def status(args: Namespace) -> None:
     mode_dependencies = modes[mode_to_view]
 
     try:
-        status_jsons = run_docker_compose_command(
-            service, "ps", mode_dependencies, options=["--format", "json"]
+        remote_dependencies = install_and_verify_dependencies(service)
+    except DependencyError as 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)
-    # If the service is not running, the status_json will be empty
-    if len(status_jsons) == 0:
-        print(f"{service.name} is not running")
+
+    # Filter out empty stdout to help us determine if the service is running
+    status_json_results = [
+        status_json for status_json in status_json_results if status_json.stdout
+    ]
+    if len(status_json_results) == 0:
+        console.warning(f"{service.name} is not running")
         return
     output = f"Service: {service.name}\n\n"
-    for status_json in status_jsons:
+    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-1.0.0/devservices/commands/stop.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+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.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
+
+
+def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
+    parser = subparsers.add_parser("stop", help="Stop a service and its dependencies")
+    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:
+        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:
+        console.warning(f"{service.name} is not running")
+        exit(0)
+
+    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)
+        except DependencyError as 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.failure(f"Failed to stop {service.name}: {dce.stderr}")
+            exit(1)
+
+    # TODO: We should factor in healthchecks here before marking service as stopped
+    state = State()
+    state.remove_started_service(service.name)

{devservices-0.0.4 → devservices-1.0.0}/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.4 → devservices-1.0.0}/devservices/constants.py

@@ -11,6 +11,7 @@ DEVSERVICES_CACHE_DIR = os.path.expanduser("~/.cache/sentry-devservices")
 DEVSERVICES_LOCAL_DIR = os.path.expanduser("~/.local/share/sentry-devservices")
 DEVSERVICES_DEPENDENCIES_CACHE_DIR = os.path.join(DEVSERVICES_CACHE_DIR, "dependencies")
 DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY = "DEVSERVICES_DEPENDENCIES_CACHE_DIR"
+STATE_DB_FILE = os.path.join(DEVSERVICES_LOCAL_DIR, "state")
 
 DEPENDENCY_CONFIG_VERSION = "v1"
 DEPENDENCY_GIT_PARTIAL_CLONE_CONFIG_OPTIONS = {
@@ -22,3 +23,5 @@ DEPENDENCY_GIT_PARTIAL_CLONE_CONFIG_OPTIONS = {
 DOCKER_COMPOSE_DOWNLOAD_URL = "https://github.com/docker/compose/releases/download"
 DEVSERVICES_DOWNLOAD_URL = "https://github.com/getsentry/devservices/releases/download"
 BINARY_PERMISSIONS = 0o755
+MAX_LOG_LINES = "100"
+LOGGER_NAME = "devservices"

{devservices-0.0.4 → devservices-1.0.0}/devservices/exceptions.py

@@ -43,6 +43,14 @@ class DevservicesUpdateError(BinaryInstallError):
     pass
 
 
+class DockerDaemonNotRunningError(Exception):
+    """Raised when the Docker daemon is not running."""
+
+    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):
     """Raised when the Docker Compose installation fails."""
 
@@ -67,17 +75,29 @@ class DependencyError(Exception):
         self.repo_link = repo_link
         self.branch = branch
 
+    def __str__(self) -> str:
+        return f"DependencyError: {self.repo_name} ({self.repo_link}) on {self.branch}"
+
+
+class UnableToCloneDependencyError(DependencyError):
+    """Raised when a dependency is unable to be cloned."""
+
+    def __str__(self) -> str:
+        return f"Unable to clone dependency: {self.repo_name} ({self.repo_link}) on {self.branch}"
+
 
 class InvalidDependencyConfigError(DependencyError):
     """Raised when a dependency's config is invalid."""
 
-    pass
+    def __str__(self) -> str:
+        return f"Invalid config for dependency: {self.repo_name} ({self.repo_link}) on {self.branch}"
 
 
 class DependencyNotInstalledError(DependencyError):
     """Raised when a dependency is not installed correctly."""
 
-    pass
+    def __str__(self) -> str:
+        return f"Dependency not installed correctly: {self.repo_name} ({self.repo_link}) on {self.branch}"
 
 
 class GitConfigError(Exception):