devservices 0.0.1__tar.gz

devservices-0.0.1/PKG-INFO

@@ -0,0 +1,12 @@
+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/README.md

@@ -0,0 +1 @@
+# devservices

devservices-0.0.1/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "devservices"
+version = "0.0.1"
+requires-python = ">=3.12"
+dependencies = [
+    "pyyaml",
+    "sentry-devenv",
+]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "mypy",
+    "pre-commit",
+    "pytest",
+    "types-PyYAML",
+]
+
+[project.scripts]
+devservices = "main:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+packages = {find = {where = ["src"]}}
+include-package-data = true
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "yaml.*"
+ignore_missing_imports = true

devservices-0.0.1/setup.cfg

@@ -0,0 +1,9 @@
+[flake8]
+max-line-length = 100
+extend-ignore = 
+	E501
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

devservices-0.0.1/src/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)

devservices-0.0.1/src/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})")

devservices-0.0.1/src/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()

devservices-0.0.1/src/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)

devservices-0.0.1/src/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()

devservices-0.0.1/src/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)

devservices-0.0.1/src/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/src/devservices.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+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/src/devservices.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+README.md
+pyproject.toml
+setup.cfg
+src/commands/__init__.py
+src/commands/list_dependencies.py
+src/commands/list_services.py
+src/commands/logs.py
+src/commands/start.py
+src/commands/status.py
+src/commands/stop.py
+src/configs/service_config.py
+src/devservices.egg-info/PKG-INFO
+src/devservices.egg-info/SOURCES.txt
+src/devservices.egg-info/dependency_links.txt
+src/devservices.egg-info/entry_points.txt
+src/devservices.egg-info/requires.txt
+src/devservices.egg-info/top_level.txt
+src/utils/__init__.py
+src/utils/console.py
+src/utils/devenv.py
+src/utils/docker_compose.py
+src/utils/services.py
+tests/testutils.py

devservices-0.0.1/src/devservices.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

devservices-0.0.1/src/devservices.egg-info/entry_points.txt

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

devservices-0.0.1/src/devservices.egg-info/requires.txt

@@ -0,0 +1,9 @@
+pyyaml
+sentry-devenv
+
+[dev]
+black
+mypy
+pre-commit
+pytest
+types-PyYAML

devservices-0.0.1/src/devservices.egg-info/top_level.txt

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

devservices-0.0.1/src/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

devservices-0.0.1/src/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}")

devservices-0.0.1/src/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,
+        )

devservices-0.0.1/src/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')

devservices-0.0.1/tests/testutils.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+
+def create_config_file(
+    tmp_path: Path, config: dict[str, object] | dict[str, dict[str, object]]
+) -> None:
+    devservices_dir = Path(tmp_path, "devservices")
+    devservices_dir.mkdir(parents=True, exist_ok=True)
+    tmp_file = Path(devservices_dir, "docker-compose.yml")
+    with tmp_file.open("w") as f:
+        yaml.dump(config, f, sort_keys=False, default_flow_style=False)