devservices 1.1.5__tar.gz → 1.2.0__tar.gz

{devservices-1.1.5 → devservices-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devservices
-Version: 1.1.5
+Version: 1.2.0
 Requires-Python: >=3.11
 License-File: LICENSE.md
 Requires-Dist: pyyaml

{devservices-1.1.5 → devservices-1.2.0}/README.md

@@ -31,7 +31,7 @@ NOTE: service-name is an optional parameter. If not provided, devservices will a
 The recommended way to install devservices is through a virtualenv in the requirements.txt. Once that is installed and a devservices config file is added, you should be able to run `devservices up` to begin local development.
 
 ```
-devservices==1.1.5
+devservices==1.2.0
 ```
 
 ### 2. Add devservices config files

{devservices-1.1.5 → devservices-1.2.0}/devservices/commands/down.py

@@ -11,19 +11,21 @@ from sentry_sdk import capture_exception
 
 from devservices.constants import CONFIG_FILE_NAME
 from devservices.constants import DEPENDENCY_CONFIG_VERSION
+from devservices.constants import DependencyType
 from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR
 from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY
 from devservices.constants import DEVSERVICES_DIR_NAME
+from devservices.constants import PROGRAMS_CONF_FILE_NAME
 from devservices.exceptions import ConfigError
 from devservices.exceptions import ConfigNotFoundError
 from devservices.exceptions import DependencyError
 from devservices.exceptions import DockerComposeError
 from devservices.exceptions import ServiceNotFoundError
+from devservices.exceptions import SupervisorError
 from devservices.utils.console import Console
 from devservices.utils.console import Status
 from devservices.utils.dependencies import construct_dependency_graph
 from devservices.utils.dependencies import DependencyNode
-from devservices.utils.dependencies import DependencyType
 from devservices.utils.dependencies import get_non_shared_remote_dependencies
 from devservices.utils.dependencies import install_and_verify_dependencies
 from devservices.utils.dependencies import InstalledRemoteDependency
@@ -35,6 +37,7 @@ from devservices.utils.services import Service
 from devservices.utils.state import ServiceRuntime
 from devservices.utils.state import State
 from devservices.utils.state import StateTables
+from devservices.utils.supervisor import SupervisorManager
 
 
 def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
@@ -105,6 +108,14 @@ def down(args: Namespace) -> None:
         active_mode_dependencies = modes.get(active_mode, [])
         mode_dependencies.update(active_mode_dependencies)
 
+    supervisor_programs = [
+        dep
+        for dep in mode_dependencies
+        if dep in service.config.dependencies
+        and service.config.dependencies[dep].dependency_type
+        == DependencyType.SUPERVISOR
+    ]
+
     with Status(
         lambda: console.warning(f"Stopping {service.name}"),
     ) as status:
@@ -129,6 +140,13 @@ def down(args: Namespace) -> None:
             )
             exit(1)
 
+        try:
+            bring_down_supervisor_programs(supervisor_programs, service, status)
+        except SupervisorError as se:
+            capture_exception(se)
+            status.failure(str(se))
+            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 = active_services.difference({service.name})
@@ -285,3 +303,24 @@ def _bring_down_dependency(
     for dependency in cmd.services:
         status.info(f"Stopping {dependency}")
     return run_cmd(cmd.full_command, current_env)
+
+
+def bring_down_supervisor_programs(
+    supervisor_programs: list[str], service: Service, status: Status
+) -> None:
+    if len(supervisor_programs) == 0:
+        return
+    programs_config_path = os.path.join(
+        service.repo_path, f"{DEVSERVICES_DIR_NAME}/{PROGRAMS_CONF_FILE_NAME}"
+    )
+    manager = SupervisorManager(
+        programs_config_path,
+        service_name=service.name,
+    )
+
+    for program in supervisor_programs:
+        status.info(f"Stopping {program}")
+        manager.stop_process(program)
+
+    status.info("Stopping supervisor daemon")
+    manager.stop_supervisor_daemon()

devservices-1.2.0/devservices/commands/foreground.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import os
+import pty
+import shlex
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+
+from sentry_sdk import capture_exception
+
+from devservices.constants import DependencyType
+from devservices.constants import DEVSERVICES_DIR_NAME
+from devservices.constants import PROGRAMS_CONF_FILE_NAME
+from devservices.exceptions import ConfigError
+from devservices.exceptions import ConfigNotFoundError
+from devservices.exceptions import ServiceNotFoundError
+from devservices.exceptions import SupervisorConfigError
+from devservices.exceptions import SupervisorProcessError
+from devservices.utils.console import Console
+from devservices.utils.services import find_matching_service
+from devservices.utils.state import State
+from devservices.utils.state import StateTables
+from devservices.utils.supervisor import SupervisorManager
+
+
+def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
+    parser = subparsers.add_parser(
+        "foreground", help="Run a service's program in the foreground"
+    )
+    parser.add_argument(
+        "program_name", help="Name of the program to run in the foreground"
+    )
+    parser.set_defaults(func=foreground)
+
+
+def foreground(args: Namespace) -> None:
+    """Run a service's program in the foreground."""
+    console = Console()
+    program_name = args.program_name
+    try:
+        service = find_matching_service()
+    except ConfigNotFoundError as e:
+        capture_exception(e, level="info")
+        console.failure(
+            f"{str(e)}. Please specify a service (i.e. `devservices down sentry`) or run the command from a directory with a devservices configuration."
+        )
+        exit(1)
+    except ConfigError as e:
+        capture_exception(e)
+        console.failure(str(e))
+        exit(1)
+    except ServiceNotFoundError as e:
+        console.failure(str(e))
+        exit(1)
+    modes = service.config.modes
+    if program_name not in service.config.dependencies:
+        console.failure(
+            f"Program {program_name} does not exist in the service's config"
+        )
+        return
+    state = State()
+    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")
+        return
+    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, [])
+        mode_dependencies.update(active_mode_dependencies)
+
+    supervisor_programs = [
+        dep
+        for dep in mode_dependencies
+        if dep in service.config.dependencies
+        and service.config.dependencies[dep].dependency_type
+        == DependencyType.SUPERVISOR
+    ]
+
+    if program_name not in supervisor_programs:
+        console.failure(
+            f"Program {program_name} is not running in any active modes of {service.name}"
+        )
+        return
+
+    programs_config_path = os.path.join(
+        service.repo_path, f"{DEVSERVICES_DIR_NAME}/{PROGRAMS_CONF_FILE_NAME}"
+    )
+
+    manager = SupervisorManager(
+        programs_config_path,
+        service_name=service.name,
+    )
+
+    try:
+        program_command = manager.get_program_command(program_name)
+    except SupervisorConfigError as e:
+        capture_exception(e, level="info")
+        console.failure(f"Error when getting program command: {str(e)}")
+        return
+
+    try:
+        # Stop the supervisor process before running in foreground
+        console.info(f"Stopping {program_name} in supervisor")
+        manager.stop_process(program_name)
+        console.info(f"Starting {program_name} in foreground")
+        argv = shlex.split(program_command)
+
+        # Run the process in foreground
+        pty.spawn(argv)
+    except SupervisorProcessError as e:
+        capture_exception(e)
+        console.failure(f"Error stopping {program_name} in supervisor: {str(e)}")
+    except (OSError, FileNotFoundError, PermissionError) as e:
+        capture_exception(e)
+        console.failure(f"Error running {program_name} in foreground: {str(e)}")
+
+    try:
+        console.info(f"Restarting {program_name} in background")
+        manager.start_process(program_name)
+    except SupervisorProcessError as e:
+        capture_exception(e)
+        console.failure(f"Error restarting {program_name} in background: {str(e)}")

{devservices-1.1.5 → devservices-1.2.0}/devservices/commands/list_services.py

@@ -4,6 +4,9 @@ from argparse import _SubParsersAction
 from argparse import ArgumentParser
 from argparse import Namespace
 
+from sentry_sdk import capture_exception
+
+from devservices.exceptions import ConfigError
 from devservices.utils.console import Console
 from devservices.utils.devenv import get_coderoot
 from devservices.utils.services import get_local_services
@@ -29,7 +32,12 @@ def list_services(args: Namespace) -> None:
     console = Console()
     # Get all of the services installed locally
     coderoot = get_coderoot()
-    services = get_local_services(coderoot)
+    try:
+        services = get_local_services(coderoot)
+    except ConfigError as e:
+        capture_exception(e)
+        console.failure(str(e))
+        return
     state = State()
     starting_services = set(state.get_service_entries(StateTables.STARTING_SERVICES))
     started_services = set(state.get_service_entries(StateTables.STARTED_SERVICES))

{devservices-1.1.5 → devservices-1.2.0}/devservices/commands/logs.py

@@ -11,15 +11,19 @@ from sentry_sdk import capture_exception
 
 from devservices.constants import CONFIG_FILE_NAME
 from devservices.constants import DEPENDENCY_CONFIG_VERSION
+from devservices.constants import DependencyType
 from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR
 from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY
 from devservices.constants import DEVSERVICES_DIR_NAME
 from devservices.constants import MAX_LOG_LINES
+from devservices.constants import PROGRAMS_CONF_FILE_NAME
 from devservices.exceptions import ConfigError
 from devservices.exceptions import ConfigNotFoundError
 from devservices.exceptions import DependencyError
 from devservices.exceptions import DockerComposeError
 from devservices.exceptions import ServiceNotFoundError
+from devservices.exceptions import SupervisorConfigError
+from devservices.exceptions import SupervisorError
 from devservices.utils.console import Console
 from devservices.utils.dependencies import install_and_verify_dependencies
 from devservices.utils.dependencies import InstalledRemoteDependency
@@ -29,6 +33,7 @@ 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
+from devservices.utils.supervisor import SupervisorManager
 
 
 def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
@@ -61,13 +66,25 @@ def logs(args: Namespace) -> None:
     except ServiceNotFoundError as e:
         console.failure(str(e))
         exit(1)
+    state = State()
 
     modes = service.config.modes
-    # TODO: allow custom modes to be used
-    mode_to_use = "default"
-    mode_dependencies = modes[mode_to_use]
+    starting_modes = set(
+        state.get_active_modes_for_service(service.name, StateTables.STARTING_SERVICES)
+    )
+    started_modes = set(
+        state.get_active_modes_for_service(service.name, StateTables.STARTED_SERVICES)
+    )
+    active_modes = starting_modes.union(started_modes)
+    mode_dependencies = set()
+    for active_mode in active_modes:
+        active_mode_dependencies = modes.get(active_mode, [])
+        mode_dependencies.update(active_mode_dependencies)
+
+    # If no active modes found but service is running, fall back to default mode
+    if not mode_dependencies and "default" in modes:
+        mode_dependencies.update(modes["default"])
 
-    state = State()
     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)
@@ -76,7 +93,9 @@ def logs(args: Namespace) -> None:
         return
 
     try:
-        remote_dependencies = install_and_verify_dependencies(service)
+        remote_dependencies = install_and_verify_dependencies(
+            service, modes=list(active_modes)
+        )
     except DependencyError as de:
         capture_exception(de)
         console.failure(
@@ -84,7 +103,7 @@ def logs(args: Namespace) -> None:
         )
         exit(1)
     try:
-        logs_output = _logs(service, remote_dependencies, mode_dependencies)
+        logs_output = _logs(service, remote_dependencies, list(mode_dependencies))
     except DockerComposeError as dce:
         capture_exception(dce, level="info")
         console.failure(f"Failed to get logs for {service.name}: {dce.stderr}")
@@ -94,6 +113,22 @@ def logs(args: Namespace) -> None:
         if log_stdout is not None:
             console.info(log_stdout)
 
+    # Get supervisor program logs
+    supervisor_programs = [
+        dep
+        for dep in mode_dependencies
+        if dep in service.config.dependencies
+        and service.config.dependencies[dep].dependency_type
+        == DependencyType.SUPERVISOR
+    ]
+
+    if len(supervisor_programs) > 0:
+        supervisor_logs = _supervisor_logs(service, supervisor_programs)
+        for program_name, log_content in supervisor_logs.items():
+            if log_content:
+                console.info(f"=== Logs for supervisor program: {program_name} ===")
+                console.info(log_content)
+
 
 def _logs(
     service: Service,
@@ -133,3 +168,44 @@ def _logs(
             cmd_outputs.append(future.result())
 
     return cmd_outputs
+
+
+def _supervisor_logs(
+    service: Service, supervisor_programs: list[str]
+) -> dict[str, str]:
+    if not supervisor_programs:
+        return {}
+
+    supervisor_logs: dict[str, str] = {}
+
+    programs_config_path = os.path.join(
+        service.repo_path, DEVSERVICES_DIR_NAME, PROGRAMS_CONF_FILE_NAME
+    )
+
+    try:
+        manager = SupervisorManager(programs_config_path, service_name=service.name)
+    except SupervisorConfigError as e:
+        capture_exception(e)
+        return supervisor_logs
+
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        futures = [
+            executor.submit(get_program_logs_with_error_handling, manager, program_name)
+            for program_name in supervisor_programs
+        ]
+        for future in concurrent.futures.as_completed(futures):
+            program_name, log_content = future.result()
+            supervisor_logs[program_name] = log_content
+
+    return supervisor_logs
+
+
+def get_program_logs_with_error_handling(
+    manager: SupervisorManager, program_name: str
+) -> tuple[str, str]:
+    try:
+        log_content = manager.get_program_logs(program_name)
+        return program_name, log_content
+    except SupervisorError as e:
+        capture_exception(e)
+        return program_name, f"Error getting logs for {program_name}: {str(e)}"

{devservices-1.1.5 → devservices-1.2.0}/devservices/commands/reset.py

@@ -7,6 +7,7 @@ from argparse import Namespace
 from sentry_sdk import capture_exception
 
 from devservices.commands.down import down
+from devservices.constants import DependencyType
 from devservices.constants import DEVSERVICES_ORCHESTRATOR_LABEL
 from devservices.exceptions import DockerDaemonNotRunningError
 from devservices.exceptions import DockerError
@@ -14,7 +15,6 @@ from devservices.utils.console import Console
 from devservices.utils.console import Status
 from devservices.utils.dependencies import construct_dependency_graph
 from devservices.utils.dependencies import DependencyNode
-from devservices.utils.dependencies import DependencyType
 from devservices.utils.docker import get_matching_containers
 from devservices.utils.docker import get_volumes_for_containers
 from devservices.utils.docker import remove_docker_resources

{devservices-1.1.5 → devservices-1.2.0}/devservices/commands/status.py

@@ -8,6 +8,7 @@ from argparse import _SubParsersAction
 from argparse import ArgumentParser
 from argparse import Namespace
 from collections import namedtuple
+from datetime import timedelta
 from typing import TypedDict
 
 from sentry_sdk import capture_exception
@@ -15,9 +16,11 @@ from sentry_sdk import capture_exception
 from devservices.constants import Color
 from devservices.constants import CONFIG_FILE_NAME
 from devservices.constants import DEPENDENCY_CONFIG_VERSION
+from devservices.constants import DependencyType
 from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR
 from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY
 from devservices.constants import DEVSERVICES_DIR_NAME
+from devservices.constants import PROGRAMS_CONF_FILE_NAME
 from devservices.exceptions import ConfigError
 from devservices.exceptions import ConfigNotFoundError
 from devservices.exceptions import DependencyError
@@ -27,7 +30,6 @@ from devservices.utils.console import Console
 from devservices.utils.dependencies import construct_dependency_graph
 from devservices.utils.dependencies import DependencyGraph
 from devservices.utils.dependencies import DependencyNode
-from devservices.utils.dependencies import DependencyType
 from devservices.utils.dependencies import install_and_verify_dependencies
 from devservices.utils.dependencies import InstalledRemoteDependency
 from devservices.utils.docker_compose import get_docker_compose_commands_to_run
@@ -37,6 +39,8 @@ from devservices.utils.services import Service
 from devservices.utils.state import ServiceRuntime
 from devservices.utils.state import State
 from devservices.utils.state import StateTables
+from devservices.utils.supervisor import ProcessInfo
+from devservices.utils.supervisor import SupervisorManager
 
 BASE_INDENTATION = "  "
 
@@ -99,8 +103,19 @@ def status(args: Namespace) -> None:
         console.warning(f"Status unavailable. {service.name} is not running standalone")
         return  # Since exit(0) is captured as an internal_error by sentry
 
+    programs_config_path = os.path.join(
+        service.repo_path, f"{DEVSERVICES_DIR_NAME}/{PROGRAMS_CONF_FILE_NAME}"
+    )
+    process_statuses = {}
+    if os.path.exists(programs_config_path):
+        supervisor_manager = SupervisorManager(
+            programs_config_path,
+            service.name,
+        )
+        process_statuses = supervisor_manager.get_all_process_info()
+
     try:
-        status_tree = get_status_for_service(service)
+        status_tree = get_status_for_service(service, process_statuses)
     except DependencyError as de:
         capture_exception(de)
         console.failure(
@@ -114,7 +129,9 @@ def status(args: Namespace) -> None:
     console.info(status_tree)
 
 
-def get_status_for_service(service: Service) -> str:
+def get_status_for_service(
+    service: Service, process_statuses: dict[str, ProcessInfo]
+) -> str:
     state = State()
 
     modes = service.config.modes
@@ -141,7 +158,10 @@ def get_status_for_service(service: Service) -> str:
 
     docker_compose_service_to_status = parse_docker_compose_status(status_json_results)
     status_tree = generate_service_status_tree(
-        service.name, dependency_graph, docker_compose_service_to_status
+        service.name,
+        process_statuses,
+        dependency_graph,
+        docker_compose_service_to_status,
     )
     return status_tree
 
@@ -188,6 +208,7 @@ def get_status_json_results(
 
 def generate_service_status_tree(
     service_name: str,
+    process_statuses: dict[str, ProcessInfo],
     dependency_graph: DependencyGraph,
     docker_compose_service_to_status: dict[str, ServiceStatusOutput],
     indentation: str = "",
@@ -227,6 +248,7 @@ def generate_service_status_tree(
             output.append(
                 process_service_with_containerized_runtime(
                     dependency,
+                    process_statuses,
                     docker_compose_service_to_status,
                     indentation + BASE_INDENTATION,
                     dependency_graph,
@@ -261,6 +283,7 @@ def process_service_with_local_runtime(
 
 def process_service_with_containerized_runtime(
     dependency: DependencyNode,
+    process_statuses: dict[str, ProcessInfo],
     docker_compose_service_to_status: dict[str, ServiceStatusOutput],
     indentation: str,
     dependency_graph: DependencyGraph,
@@ -268,13 +291,14 @@ def process_service_with_containerized_runtime(
     if len(dependency_graph.graph[dependency]) > 0:
         return generate_service_status_tree(
             dependency.name,
+            process_statuses,
             dependency_graph,
             docker_compose_service_to_status,
             indentation,
         )
     else:
         return generate_service_status_details(
-            dependency, docker_compose_service_to_status, indentation
+            dependency, process_statuses, docker_compose_service_to_status, indentation
         )
 
 
@@ -301,16 +325,23 @@ def parse_docker_compose_status(
 
 def generate_service_status_details(
     dependency: DependencyNode,
+    process_statuses: dict[str, ProcessInfo],
     docker_compose_service_to_status: dict[str, ServiceStatusOutput],
     indentation: str,
 ) -> str:
     output = [f"{indentation}{Color.BOLD}{dependency.name}{Color.RESET}:"]
 
+    # Handle supervisor dependencies
+    if dependency.dependency_type == DependencyType.SUPERVISOR:
+        return generate_supervisor_status_details(
+            dependency, process_statuses, indentation
+        )
+
     if dependency.name not in docker_compose_service_to_status:
         return "\n".join(
             [
                 *output,
-                f"{indentation}{BASE_INDENTATION}Type: container",
+                (f"{indentation}{BASE_INDENTATION}Type: container"),
                 f"{indentation}{BASE_INDENTATION}Status: N/A",
             ]
         )
@@ -349,7 +380,7 @@ def handle_started_service(dependency: DependencyNode, indentation: str) -> str:
                 f"{indentation}{BASE_INDENTATION}Runtime: local",
             ]
         )
-    service_output = get_status_for_service(service_with_local_runtime)
+    service_output = get_status_for_service(service_with_local_runtime, {})
     return "\n".join(
         [f"{indentation}{line}" for line in service_output.splitlines()],
     )
@@ -365,3 +396,56 @@ def format_health(health: str) -> str:
         else Color.YELLOW
     )
     return f"{color}{health}{Color.RESET}"
+
+
+def generate_supervisor_status_details(
+    dependency: DependencyNode,
+    process_statuses: dict[str, ProcessInfo],
+    indentation: str,
+) -> str:
+    """Generate status details for supervisor dependencies."""
+    output = [f"{indentation}{Color.BOLD}{dependency.name}{Color.RESET}:"]
+
+    process_info = process_statuses.get(dependency.name)
+
+    if process_info is None:
+        return "\n".join(
+            [
+                *output,
+                f"{indentation}{BASE_INDENTATION}Type: process",
+                f"{indentation}{BASE_INDENTATION}Status: N/A (process not found)",
+            ]
+        )
+
+    uptime_str = format_uptime(process_info["uptime"])
+
+    details = [
+        "Type: process",
+        f"Status: {process_info['state_name'].lower()}",
+        f"PID: {process_info['pid'] if process_info['pid'] > 0 else 'N/A'}",
+        f"Uptime: {uptime_str}",
+    ]
+
+    output.extend(f"{indentation}{BASE_INDENTATION}{detail}" for detail in details)
+
+    return "\n".join(output)
+
+
+def format_uptime(uptime_seconds: int) -> str:
+    """Format uptime seconds into a human-readable string."""
+    SECONDS_PER_MINUTE = 60
+    SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE
+
+    td = timedelta(seconds=uptime_seconds)
+    days = td.days
+    hours, remainder = divmod(td.seconds, SECONDS_PER_HOUR)
+    minutes, seconds = divmod(remainder, SECONDS_PER_MINUTE)
+
+    if days > 0:
+        return f"{days}d {hours}h {minutes}m {seconds}s"
+    elif hours > 0:
+        return f"{hours}h {minutes}m {seconds}s"
+    elif minutes > 0:
+        return f"{minutes}m {seconds}s"
+    else:
+        return f"{seconds}s"