devservices 0.0.1__py3-none-any.whl

commands/list_dependencies.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+
+from utils.services import find_matching_service
+
+
+def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
+    parser = subparsers.add_parser(
+        "list-dependencies", help="List the dependencies of a service"
+    )
+    parser.add_argument(
+        "service_name",
+        help="Name of the service to list the dependencies of",
+        nargs="?",
+        default=None,
+    )
+    parser.set_defaults(func=list_dependencies)
+
+
+def list_dependencies(args: Namespace) -> None:
+    """List the dependencies of a service."""
+    service_name = args.service_name
+
+    try:
+        service = find_matching_service(service_name)
+    except Exception as e:
+        print(e)
+        exit(1)
+
+    dependencies = service.config.dependencies
+
+    if not dependencies:
+        print(f"No dependencies found for {service.name}")
+        return
+
+    print(f"Dependencies of {service.name}:")
+    for dependency_key, dependency_info in dependencies.items():
+        print("-", dependency_key, ":", dependency_info.description)

commands/list_services.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+
+from utils.devenv import get_coderoot
+from utils.services import get_local_services
+
+
+def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
+    parser = subparsers.add_parser(
+        "list-services", help="List the services installed locally"
+    )
+    parser.set_defaults(func=list_services)
+
+
+def list_services(args: Namespace) -> None:
+    """List the services installed locally."""
+
+    # Get all of the services installed locally
+    coderoot = get_coderoot()
+    services = get_local_services(coderoot)
+
+    if not services:
+        print("No services found")
+        return
+
+    print("Services installed locally:")
+    for service in services:
+        print("-", service.name, f"({service.repo_path})")

commands/logs.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import os
+import sys
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+
+from constants import DEVSERVICES_DIR_NAME
+from constants import DOCKER_COMPOSE_FILE_NAME
+from exceptions import DockerComposeError
+from utils.docker_compose import run_docker_compose_command
+from utils.services import find_matching_service
+
+
+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."""
+    service_name = args.service_name
+    try:
+        service = find_matching_service(service_name)
+    except Exception as e:
+        print(e)
+        exit(1)
+    modes = service.config.modes
+    # TODO: allow custom modes to be used
+    mode_to_use = "default"
+    mode_dependencies = " ".join(modes[mode_to_use])
+    service_config_file_path = os.path.join(
+        service.repo_path, DEVSERVICES_DIR_NAME, DOCKER_COMPOSE_FILE_NAME
+    )
+    try:
+        logs = run_docker_compose_command(
+            f"-f {service_config_file_path} logs {mode_dependencies}"
+        )
+    except DockerComposeError as dce:
+        print(f"Failed to get logs for {service.name}: {dce.stderr}")
+        exit(1)
+    sys.stdout.write(logs.stdout)
+    sys.stdout.flush()

commands/start.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import os
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+
+from constants import DEVSERVICES_DIR_NAME
+from constants import DOCKER_COMPOSE_FILE_NAME
+from exceptions import DockerComposeError
+from utils.console import Status
+from utils.docker_compose import run_docker_compose_command
+from utils.services import find_matching_service
+
+
+def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
+    parser = subparsers.add_parser("start", help="Start a service and its dependencies")
+    parser.add_argument(
+        "service_name", help="Name of the service to start", nargs="?", default=None
+    )
+    parser.set_defaults(func=start)
+
+
+def start(args: Namespace) -> None:
+    """Start a service and its dependencies."""
+    service_name = args.service_name
+    try:
+        service = find_matching_service(service_name)
+    except Exception as e:
+        print(e)
+        exit(1)
+    modes = service.config.modes
+    # TODO: allow custom modes to be used
+    mode_to_start = "default"
+    mode_dependencies = " ".join(modes[mode_to_start])
+    service_config_file_path = os.path.join(
+        service.repo_path, DEVSERVICES_DIR_NAME, DOCKER_COMPOSE_FILE_NAME
+    )
+    with Status(f"Starting {service.name}", f"{service.name} started") as status:
+        try:
+            run_docker_compose_command(
+                f"-f {service_config_file_path} up -d {mode_dependencies}"
+            )
+        except DockerComposeError as dce:
+            status.print(f"Failed to start {service.name}: {dce.stderr}")
+            exit(1)

commands/status.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+
+from constants import DEVSERVICES_DIR_NAME
+from constants import DOCKER_COMPOSE_FILE_NAME
+from exceptions import DockerComposeError
+from utils.docker_compose import run_docker_compose_command
+from utils.services import find_matching_service
+
+LINE_LENGTH = 40
+
+
+def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
+    parser = subparsers.add_parser("status", help="View status of a service")
+    parser.add_argument(
+        "service_name",
+        help="Name of the service to view status for",
+        nargs="?",
+        default=None,
+    )
+    parser.set_defaults(func=status)
+
+
+def format_status_output(status_json: str) -> str:
+    # Docker compose ps is line delimited json, so this constructs this into an array we can use
+    service_statuses = status_json.split("\n")[:-1]
+    output = []
+    output.append("-" * LINE_LENGTH)
+    for service_status in service_statuses:
+        service = json.loads(service_status)
+        name = service["Service"]
+        state = service["State"]
+        health = service.get("Health", "N/A")
+        ports = service.get("Publishers", [])
+        running_for = service.get("RunningFor", "N/A")
+
+        output.append(f"{name}")
+        output.append(f"Status: {state}")
+        output.append(f"Health: {health}")
+        output.append(f"Uptime: {running_for}")
+
+        if ports:
+            output.append("Ports:")
+            for port in ports:
+                output.append(
+                    f"  {port['PublishedPort']} -> {port['TargetPort']}/{port['Protocol']}"
+                )
+        else:
+            output.append("No ports exposed")
+
+        output.append("")  # Empty line for readability
+
+    return "\n".join(output)
+
+
+def status(args: Namespace) -> None:
+    """Start a service and its dependencies."""
+    service_name = args.service_name
+    try:
+        service = find_matching_service(service_name)
+    except Exception as e:
+        print(e)
+        exit(1)
+    modes = service.config.modes
+    # TODO: allow custom modes to be used
+    mode_to_view = "default"
+    mode_dependencies = modes[mode_to_view]
+    service_config_file_path = os.path.join(
+        service.repo_path, DEVSERVICES_DIR_NAME, DOCKER_COMPOSE_FILE_NAME
+    )
+    mode_dependencies = " ".join(modes[mode_to_view])
+    try:
+        status_json = run_docker_compose_command(
+            f"-f {service_config_file_path} ps {mode_dependencies} --format json"
+        ).stdout
+    except DockerComposeError as dce:
+        print(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 not status_json:
+        print(f"{service.name} is not running")
+        return
+    output = f"Service: {service.name}\n\n"
+    output += format_status_output(status_json)
+    output += "=" * LINE_LENGTH
+    sys.stdout.write(output + "\n")
+    sys.stdout.flush()

commands/stop.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import os
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+
+from constants import DEVSERVICES_DIR_NAME
+from constants import DOCKER_COMPOSE_FILE_NAME
+from exceptions import DockerComposeError
+from utils.console import Status
+from utils.docker_compose import run_docker_compose_command
+from utils.services import find_matching_service
+
+
+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.set_defaults(func=stop)
+
+
+def stop(args: Namespace) -> None:
+    """Stop a service and its dependencies."""
+    service_name = args.service_name
+    try:
+        service = find_matching_service(service_name)
+    except Exception as e:
+        print(e)
+        exit(1)
+    modes = service.config.modes
+    # TODO: allow custom modes to be used
+    mode_to_stop = "default"
+    mode_dependencies = " ".join(modes[mode_to_stop])
+    service_config_file_path = os.path.join(
+        service.repo_path, DEVSERVICES_DIR_NAME, DOCKER_COMPOSE_FILE_NAME
+    )
+    with Status(f"Stopping {service.name}", f"{service.name} stopped") as status:
+        try:
+            run_docker_compose_command(
+                f"-f {service_config_file_path} down {mode_dependencies}"
+            )
+        except DockerComposeError as dce:
+            status.print(f"Failed to stop {service.name}: {dce.stderr}")
+            exit(1)

configs/service_config.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+import yaml
+from constants import DEVSERVICES_DIR_NAME
+from constants import DOCKER_COMPOSE_FILE_NAME
+from exceptions import ConfigNotFoundError
+from exceptions import ConfigParseError
+from exceptions import ConfigValidationError
+
+
+VALID_VERSIONS = [0.1]
+
+
+@dataclass
+class Dependency:
+    description: str
+    link: str | None = None
+
+
+@dataclass
+class ServiceConfig:
+    version: float
+    service_name: str
+    dependencies: dict[str, Dependency]
+    modes: dict[str, list[str]]
+
+    def __post_init__(self) -> None:
+        self._validate()
+
+    def _validate(self) -> None:
+        if not self.version:
+            raise ConfigValidationError("Version is required in service config")
+
+        if self.version not in VALID_VERSIONS:
+            raise ConfigValidationError(
+                f"Invalid version '{self.version}' in service config"
+            )
+
+        if not self.service_name:
+            raise ConfigValidationError("Service name is required in service config")
+
+        if "default" not in self.modes:
+            raise ConfigValidationError("Default mode is required in service config")
+
+        for mode, services in self.modes.items():
+            if not isinstance(services, list):
+                raise ConfigValidationError(f"Services in mode '{mode}' must be a list")
+            for service in services:
+                if service not in self.dependencies:
+                    raise ConfigValidationError(
+                        f"Service '{service}' in mode '{mode}' is not defined in dependencies"
+                    )
+
+
+def load_service_config_from_file(repo_path: str) -> ServiceConfig:
+    config_path = os.path.join(
+        repo_path, DEVSERVICES_DIR_NAME, DOCKER_COMPOSE_FILE_NAME
+    )
+    if not os.path.exists(config_path):
+        raise ConfigNotFoundError(f"Config file not found in directory: {config_path}")
+    with open(config_path, "r") as stream:
+        try:
+            config = yaml.safe_load(stream)
+        except yaml.YAMLError as yml_error:
+            raise ConfigParseError(
+                f"Error parsing config file: {yml_error}"
+            ) from yml_error
+
+        if "x-sentry-service-config" not in config:
+            raise ConfigParseError(
+                "Config file does not contain 'x-sentry-service-config' key"
+            )
+        service_config_data = config.get("x-sentry-service-config")
+
+        try:
+            dependencies = {
+                key: Dependency(**value)
+                for key, value in service_config_data.get("dependencies", {}).items()
+            }
+        except TypeError as type_error:
+            raise ConfigParseError(
+                f"Error parsing service dependencies: {type_error}"
+            ) from type_error
+
+        service_config = ServiceConfig(
+            version=service_config_data.get("version"),
+            service_name=service_config_data.get("service_name"),
+            dependencies=dependencies,
+            modes=service_config_data.get("modes", {}),
+        )
+
+        return service_config

devservices-0.0.1.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.1
+Name: devservices
+Version: 0.0.1
+Requires-Python: >=3.12
+Requires-Dist: pyyaml
+Requires-Dist: sentry-devenv
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: types-PyYAML; extra == "dev"
+

devservices-0.0.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+commands/list_dependencies.py,sha256=Yi3VO0YGgVnuvZHuQgZt5lqifEKf_GpJx_nTjAu4mV4,1172
+commands/list_services.py,sha256=KBE2lIYZiHhJDBRp8NT33xzby0-hM1dKzO3sP4UcMtk,872
+commands/logs.py,sha256=_zwiendvSVXvvjfM29nApQYdn1kZPc2xLdWwfr_sKgE,1577
+commands/start.py,sha256=zDqnaa9XHR0uOO3nUheuA-lZOiKAOFdhORlNojwZRFk,1632
+commands/status.py,sha256=VFY-M3Je93m29XVMPf8pXlR5ZAA1KA_ywcU5HjgcKpA,3068
+commands/stop.py,sha256=mdR3hTUpdm4__AcLCam8aRNlt0JJrMcTatlUqBJ2aBs,1622
+configs/service_config.py,sha256=jyeNjQmkreL7mGQPP3y_aAiDUS4uyzCfHYrRhW23F7c,3108
+utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+utils/console.py,sha256=hweyYeX6RB9tXJ9AabZfxuXMDZ9duXgz_zrYLJhLeeQ,1945
+utils/devenv.py,sha256=qxh_vwM6gTMAjOtAJPBU0iWPkjkUXIrNsoGs4yt_9-k,786
+utils/docker_compose.py,sha256=P2XFBjIL1avMmHdyHnX5FE3YwQD-eKtIbvlEhYR6Dz4,534
+utils/services.py,sha256=--FTnonJ9C8U1HRNwZOkxZyXpAWwDV4guLB_p_8ISzw,1871
+devservices-0.0.1.dist-info/METADATA,sha256=DHUHhE2RdTPqR6LJx29oSjj3-8n97TExoGpoCzx9zuA,348
+devservices-0.0.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+devservices-0.0.1.dist-info/entry_points.txt,sha256=471CQlH2h8oMig0LMF-TqmYZ8UCFVzPxJgn4gxYIGws,42
+devservices-0.0.1.dist-info/top_level.txt,sha256=wq_0FL0YzIpZhRP7mwJCU1oveQLmA4Ub4vQ6z5D_CKg,23
+devservices-0.0.1.dist-info/RECORD,,

devservices-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

devservices-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+devservices = main:main

devservices-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+commands
+configs
+utils

utils/console.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import sys
+import threading
+import time
+from types import TracebackType
+
+
+ANIMATION_FRAMES = ("⠟", "⠯", "⠷", "⠾", "⠽", "⠻")
+
+
+class Status:
+    """Shows loading status in the terminal."""
+
+    def __init__(
+        self, start_message: str | None = None, end_message: str | None = None
+    ) -> None:
+        self.start_message = start_message
+        self.end_message = end_message
+        self._stop_loading = threading.Event()
+        self._loading_thread = threading.Thread(target=self._loading_animation)
+        self._exception_occured = False
+
+    def print(self, message: str) -> None:
+        sys.stdout.write("\r" + message + "\n")
+        sys.stdout.flush()
+
+    def start(self) -> None:
+        if self.start_message:
+            print(self.start_message)
+        self._loading_thread.start()
+
+    def stop(self) -> None:
+        self._stop_loading.set()
+        self._loading_thread.join()
+        sys.stdout.write("\r")
+        sys.stdout.flush()
+        if self.end_message and not self._exception_occured:
+            print(self.end_message)
+
+    def _loading_animation(self) -> None:
+        idx = 0
+        while not self._stop_loading.is_set():
+            sys.stdout.write("\r" + ANIMATION_FRAMES[idx % len(ANIMATION_FRAMES)] + " ")
+            sys.stdout.flush()
+            idx += 1
+            time.sleep(0.1)
+
+    def __enter__(self) -> Status:
+        self.start()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_inst: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool:
+        self._exception_occured = exc_type is not None
+        self.stop()
+        if exc_type:
+            if exc_type in (KeyboardInterrupt,):
+                # Don't print anything if the user interrupts the process
+                return True
+            else:
+                return False
+        return False

utils/devenv.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import os
+from configparser import ConfigParser
+from configparser import NoOptionError
+from configparser import NoSectionError
+
+from devenv.constants import home
+from devenv.lib.config import read_config
+
+
+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="")
+    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")
+    except Exception as e:
+        raise Exception(f"Failed to read config: {e}")

utils/docker_compose.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import subprocess
+
+from exceptions import DockerComposeError
+
+
+def run_docker_compose_command(command: str) -> subprocess.CompletedProcess[str]:
+    cmd = ["docker", "compose"] + command.split()
+    try:
+        return subprocess.run(cmd, check=True, capture_output=True, text=True)
+    except subprocess.CalledProcessError as e:
+        raise DockerComposeError(
+            command=command,
+            returncode=e.returncode,
+            stdout=e.stdout,
+            stderr=e.stderr,
+        )

utils/services.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+from configs.service_config import ServiceConfig
+from exceptions import ConfigNotFoundError
+from exceptions import ConfigParseError
+from exceptions import ConfigValidationError
+from exceptions import ServiceNotFoundError
+from utils.devenv import get_coderoot
+
+
+@dataclass
+class Service:
+    name: str
+    repo_path: str
+    config: ServiceConfig
+
+
+def get_local_services(coderoot: str) -> list[Service]:
+    """Get a list of services in the coderoot."""
+    from configs.service_config import load_service_config_from_file
+
+    services = []
+    for repo in os.listdir(coderoot):
+        repo_path = os.path.join(coderoot, repo)
+        try:
+            service_config = load_service_config_from_file(repo_path)
+        except (ConfigNotFoundError, ConfigParseError, ConfigValidationError):
+            continue
+        service_name = service_config.service_name
+        services.append(
+            Service(
+                name=service_name,
+                repo_path=repo_path,
+                config=service_config,
+            )
+        )
+    return services
+
+
+def find_matching_service(service_name: str | None = None) -> Service:
+    """Find a service with the given name."""
+    if service_name is None:
+        from configs.service_config import load_service_config_from_file
+
+        repo_path = os.getcwd()
+        service_config = load_service_config_from_file(repo_path)
+
+        return Service(
+            name=service_config.service_name,
+            repo_path=repo_path,
+            config=service_config,
+        )
+    coderoot = get_coderoot()
+    services = get_local_services(coderoot)
+    for service in services:
+        if service.name.lower() == service_name.lower():
+            return service
+    raise ServiceNotFoundError(f'Service "{service_name}" not found')