devservices 1.1.1__tar.gz → 1.1.2__tar.gz

{devservices-1.1.1 → devservices-1.1.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: devservices
-Version: 1.1.1
-Requires-Python: >=3.10
+Version: 1.1.2
+Requires-Python: >=3.11
 License-File: LICENSE.md
 Requires-Dist: pyyaml
 Requires-Dist: sentry-devenv

{devservices-1.1.1 → devservices-1.1.2}/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.1
+devservices==1.1.2
 ```
 
 ### 2. Add devservices config files

devservices-1.1.2/devenv/sync.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from devenv.lib import config
+from devenv.lib import proc
+from devenv.lib import venv
+
+
+def main(context: dict[str, str]) -> int:
+    reporoot = context["reporoot"]
+
+    venv_dir, python_version, requirements, editable_paths, bins = venv.get(
+        reporoot,
+        "venv",
+    )
+    url, sha256 = config.get_python(reporoot, python_version)
+    print(f"ensuring venv at {venv_dir}...")
+    venv.ensure(venv_dir, python_version, url, sha256)
+
+    print(f"syncing venv with {requirements}...")
+    venv.sync(reporoot, venv_dir, requirements, editable_paths, bins)
+
+    proc.run(("pre-commit", "install", "--install-hooks", "-f"))
+
+    return 0

{devservices-1.1.1 → devservices-1.1.2}/devservices/commands/down.py

@@ -53,6 +53,12 @@ def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
         action="store_true",
         default=False,
     )
+    parser.add_argument(
+        "--exclude-local",
+        help="Exclude dependencies with local runtime from being brought down",
+        action="store_true",
+        default=False,
+    )
     parser.set_defaults(func=down)
 
 
@@ -77,6 +83,7 @@ def down(args: Namespace) -> None:
         exit(1)
 
     modes = service.config.modes
+    exclude_local = args.exclude_local
 
     state = State()
     starting_services = set(state.get_service_entries(StateTables.STARTING_SERVICES))
@@ -113,7 +120,7 @@ def down(args: Namespace) -> None:
             exit(1)
         try:
             remote_dependencies = get_non_shared_remote_dependencies(
-                service, remote_dependencies
+                service, remote_dependencies, exclude_local
             )
         except DependencyError as de:
             capture_exception(de)
@@ -125,13 +132,13 @@ def down(args: Namespace) -> None:
         # 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})
-        services_with_local_runtime = state.get_services_by_runtime(
+        services_with_local_runtimes = state.get_services_by_runtime(
             ServiceRuntime.LOCAL
         )
         dependent_service_name = None
         # We can ignore checking if anything relies on the service
         # if it is a locally running service
-        if service.name not in services_with_local_runtime:
+        if service.name not in services_with_local_runtimes:
             dependent_service_name = _get_dependent_service(
                 service, other_started_services, state
             )
@@ -140,7 +147,11 @@ def down(args: Namespace) -> None:
         if dependent_service_name is None:
             try:
                 bring_down_service(
-                    service, remote_dependencies, list(mode_dependencies), status
+                    service,
+                    remote_dependencies,
+                    list(mode_dependencies),
+                    exclude_local,
+                    status,
                 )
             except DockerComposeError as dce:
                 capture_exception(dce, level="info")
@@ -154,6 +165,24 @@ def down(args: Namespace) -> None:
     # TODO: We should factor in healthchecks here before marking service as not running
     state.remove_service_entry(service.name, StateTables.STARTING_SERVICES)
     state.remove_service_entry(service.name, StateTables.STARTED_SERVICES)
+
+    dependencies_with_local_runtimes = set()
+    for service_with_local_runtime in services_with_local_runtimes:
+        if service_with_local_runtime in {
+            dep.service_name for dep in remote_dependencies
+        }:
+            dependencies_with_local_runtimes.add(service_with_local_runtime)
+
+    active_dependencies_with_local_runtimes = set()
+    for dependency_with_local_runtime in dependencies_with_local_runtimes:
+        if dependency_with_local_runtime in active_services:
+            active_dependencies_with_local_runtimes.add(dependency_with_local_runtime)
+
+    if not exclude_local and len(active_dependencies_with_local_runtimes) > 0:
+        status.warning("Stopping dependencies with local runtimes...")
+        for local_dependency in active_dependencies_with_local_runtimes:
+            down(Namespace(service_name=local_dependency, exclude_local=exclude_local))
+
     if dependent_service_name is None:
         console.success(f"{service.name} stopped")
 
@@ -162,6 +191,7 @@ def bring_down_service(
     service: Service,
     remote_dependencies: set[InstalledRemoteDependency],
     mode_dependencies: list[str],
+    exclude_local: bool,
     status: Status,
 ) -> None:
     relative_local_dependency_directory = os.path.relpath(
@@ -171,30 +201,40 @@ def bring_down_service(
     service_config_file_path = os.path.join(
         service.repo_path, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME
     )
+
     # Set the environment variable for the local dependencies directory to be used by docker compose
     current_env = os.environ.copy()
     current_env[
         DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY
     ] = relative_local_dependency_directory
     state = State()
-    # We want to ignore any dependencies that are set to run locally
-    locally_running_services = state.get_services_by_runtime(ServiceRuntime.LOCAL)
-    mode_dependencies = [
-        dep for dep in mode_dependencies if dep not in locally_running_services
-    ]
-    remote_dependencies = {
-        dep
-        for dep in remote_dependencies
-        if dep.service_name not in locally_running_services
-    }
+
+    # We want to ignore any dependencies that are set to run locally if we are excluding local dependencies
+    services_with_local_runtimes = state.get_services_by_runtime(ServiceRuntime.LOCAL)
+
+    dependencies_with_local_runtimes = set()
+    for service_with_local_runtime in services_with_local_runtimes:
+        if service_with_local_runtime in {
+            dep.service_name for dep in remote_dependencies
+        }:
+            dependencies_with_local_runtimes.add(service_with_local_runtime)
+
     docker_compose_commands = get_docker_compose_commands_to_run(
         service=service,
-        remote_dependencies=list(remote_dependencies),
+        remote_dependencies=[
+            dep
+            for dep in remote_dependencies
+            if dep.service_name not in dependencies_with_local_runtimes
+        ],
         current_env=current_env,
         command="stop",
         options=[],
         service_config_file_path=service_config_file_path,
-        mode_dependencies=mode_dependencies,
+        mode_dependencies=[
+            dep
+            for dep in mode_dependencies
+            if dep not in dependencies_with_local_runtimes
+        ],
     )
 
     cmd_outputs = []

devservices-1.1.2/devservices/commands/serve.py

@@ -0,0 +1,68 @@
+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 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 SupervisorConfigError
+from devservices.utils.console import Console
+from devservices.utils.services import find_matching_service
+from devservices.utils.supervisor import SupervisorManager
+
+
+def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
+    # prefix_chars is a hack to allow all options to be passed through to the devserver without argparse complaining
+    parser = subparsers.add_parser(
+        "serve", help="Serve the devserver", prefix_chars="+"
+    )
+    parser.add_argument(
+        "extra", nargs="*", help="Flags to pass through to the devserver"
+    )
+    parser.set_defaults(func=serve)
+
+
+def serve(args: Namespace) -> None:
+    """Serve the devserver."""
+    console = Console()
+
+    try:
+        service = find_matching_service()
+    except ConfigNotFoundError as e:
+        console.failure(
+            f"{str(e)}. Please run the command from a directory with a valid devservices configuration."
+        )
+        return
+    except ConfigError as e:
+        capture_exception(e)
+        console.failure(str(e))
+        exit(1)
+
+    programs_config_path = os.path.join(
+        service.repo_path, f"{DEVSERVICES_DIR_NAME}/{PROGRAMS_CONF_FILE_NAME}"
+    )
+    if not os.path.exists(programs_config_path):
+        console.failure(f"No programs.conf file found in {programs_config_path}.")
+        return
+    manager = SupervisorManager(
+        programs_config_path,
+        service_name=service.name,
+    )
+
+    try:
+        devserver_command = manager.get_program_command("devserver")
+    except SupervisorConfigError as e:
+        capture_exception(e, level="info")
+        console.failure(f"Error when getting devserver command: {str(e)}")
+        return
+
+    argv = shlex.split(devserver_command) + args.extra
+    pty.spawn(argv)

{devservices-1.1.1 → devservices-1.1.2}/devservices/commands/toggle.py

@@ -40,7 +40,7 @@ def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
     parser.add_argument(
         "runtime",
         help="Runtime to use for the service",
-        choices=[ServiceRuntime.CONTAINERIZED, ServiceRuntime.LOCAL],
+        choices=[runtime.value for runtime in ServiceRuntime],
         nargs="?",
         default=None,
     )
@@ -71,7 +71,7 @@ def toggle(args: Namespace) -> None:
     state = State()
     current_runtime = state.get_service_runtime(service.name)
     if desired_runtime is None:
-        desired_runtime = get_opposite_runtime(current_runtime)
+        desired_runtime = get_opposite_runtime(current_runtime).value
     if current_runtime == desired_runtime:
         console.warning(
             f"{service.name} is already running in {desired_runtime} runtime"
@@ -105,7 +105,7 @@ def handle_transition_to_local_runtime(service_to_transition: Service) -> None:
     if service_to_transition.name in active_services:
         state.update_service_runtime(service_to_transition.name, ServiceRuntime.LOCAL)
         console.success(
-            f"{service_to_transition.name} is now running in {ServiceRuntime.LOCAL} runtime"
+            f"{service_to_transition.name} is now running in {ServiceRuntime.LOCAL.value} runtime"
         )
         return
 
@@ -196,7 +196,7 @@ def restart_dependent_services(
     console = Console()
     with Status(
         on_start=lambda: console.warning(
-            f"Restarting dependent services to ensure {service_name} is running in a {ServiceRuntime.CONTAINERIZED} runtime"
+            f"Restarting dependent services to ensure {service_name} is running in a {ServiceRuntime.CONTAINERIZED.value} runtime"
         ),
     ) as status:
         for dependent_service in dependent_services:
@@ -223,6 +223,7 @@ def bring_down_containerized_service(
 ) -> None:
     """Bring down a containerized service running within another service."""
     console = Console()
+    exclude_local = True
     with Status(
         lambda: console.warning(f"Stopping {service.name}"),
     ) as status:
@@ -242,7 +243,7 @@ def bring_down_containerized_service(
             exit(1)
         try:
             remote_dependencies = get_non_shared_remote_dependencies(
-                service, remote_dependencies
+                service, remote_dependencies, exclude_local
             )
         except DependencyError as de:
             capture_exception(de)
@@ -252,7 +253,11 @@ def bring_down_containerized_service(
             exit(1)
         try:
             bring_down_service(
-                service, remote_dependencies, sorted(list(mode_dependencies)), status
+                service,
+                remote_dependencies,
+                sorted(list(mode_dependencies)),
+                exclude_local,
+                status,
             )
         except DockerComposeError as dce:
             capture_exception(dce, level="info")

{devservices-1.1.1 → devservices-1.1.2}/devservices/commands/up.py

@@ -56,10 +56,16 @@ def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
         help="Mode to use for the service",
         default="default",
     )
+    parser.add_argument(
+        "--exclude-local",
+        help="Exclude dependencies with local runtime from being started",
+        action="store_true",
+        default=False,
+    )
     parser.set_defaults(func=up)
 
 
-def up(args: Namespace) -> None:
+def up(args: Namespace, existing_status: Status | None = None) -> None:
     """Bring up a service and its dependencies."""
     console = Console()
     service_name = args.service_name
@@ -85,8 +91,12 @@ def up(args: Namespace) -> None:
     state = State()
 
     with Status(
-        lambda: console.warning(f"Starting '{service.name}' in mode: '{mode}'"),
-        lambda: console.success(f"{service.name} started"),
+        lambda: console.warning(f"Starting '{service.name}' in mode: '{mode}'")
+        if existing_status is None
+        else existing_status.warning(f"Starting '{service.name}' in mode: '{mode}'"),
+        lambda: console.success(f"{service.name} started")
+        if existing_status is None
+        else existing_status.success(f"{service.name} started"),
     ) as status:
         services_with_local_runtime = state.get_services_by_runtime(
             ServiceRuntime.LOCAL
@@ -99,9 +109,10 @@ def up(args: Namespace) -> None:
                 and service_with_local_runtime in modes[mode]
             ):
                 skipped_services.add(service_with_local_runtime)
-                status.warning(
-                    f"Skipping '{service_with_local_runtime}' as it is set to run locally"
-                )
+                if args.exclude_local:
+                    status.warning(
+                        f"Skipping '{service_with_local_runtime}' as it is set to run locally"
+                    )
         try:
             status.info("Retrieving dependencies")
             remote_dependencies = install_and_verify_dependencies(
@@ -131,9 +142,10 @@ def up(args: Namespace) -> None:
                 and service_with_local_runtime not in skipped_services
             ):
                 skipped_services.add(service_with_local_runtime)
-                status.warning(
-                    f"Skipping '{service_with_local_runtime}' as it is set to run locally"
-                )
+                if args.exclude_local:
+                    status.warning(
+                        f"Skipping '{service_with_local_runtime}' as it is set to run locally"
+                    )
         # We want to ignore any dependencies that are set to run locally
         mode_dependencies = [
             dep for dep in mode_dependencies if dep not in services_with_local_runtime
@@ -144,6 +156,18 @@ def up(args: Namespace) -> None:
             if dep.service_name not in services_with_local_runtime
         }
         try:
+            if not args.exclude_local:
+                status.warning("Starting dependencies with local runtimes...")
+                for skipped_service in skipped_services:
+                    up(
+                        Namespace(
+                            service_name=skipped_service,
+                            mode=mode,
+                            exclude_local=True,
+                        ),
+                        status,
+                    )
+                status.warning(f"Continuing with service '{service.name}'")
             _up(service, [mode], remote_dependencies, mode_dependencies, status)
         except DockerComposeError as dce:
             capture_exception(dce, level="info")

{devservices-1.1.1 → devservices-1.1.2}/devservices/constants.py

@@ -18,6 +18,7 @@ class Color:
 MINIMUM_DOCKER_COMPOSE_VERSION = "2.29.7"
 DEVSERVICES_DIR_NAME = "devservices"
 CONFIG_FILE_NAME = "config.yml"
+PROGRAMS_CONF_FILE_NAME = "programs.conf"
 DOCKER_CONFIG_DIR = os.environ.get("DOCKER_CONFIG", os.path.expanduser("~/.docker"))
 DOCKER_USER_PLUGIN_DIR = os.path.join(DOCKER_CONFIG_DIR, "cli-plugins/")
 

{devservices-1.1.1 → devservices-1.1.2}/devservices/main.py

@@ -24,6 +24,7 @@ from devservices.commands import list_dependencies
 from devservices.commands import list_services
 from devservices.commands import logs
 from devservices.commands import purge
+from devservices.commands import serve
 from devservices.commands import status
 from devservices.commands import toggle
 from devservices.commands import up
@@ -147,6 +148,7 @@ def main() -> None:
     logs.add_parser(subparsers)
     update.add_parser(subparsers)
     purge.add_parser(subparsers)
+    serve.add_parser(subparsers)
     toggle.add_parser(subparsers)
 
     args = parser.parse_args()

{devservices-1.1.1 → devservices-1.1.2}/devservices/utils/dependencies.py

@@ -39,6 +39,7 @@ from devservices.exceptions import UnableToCloneDependencyError
 from devservices.utils.file_lock import lock
 from devservices.utils.services import find_matching_service
 from devservices.utils.services import Service
+from devservices.utils.state import ServiceRuntime
 from devservices.utils.state import State
 from devservices.utils.state import StateTables
 
@@ -279,7 +280,9 @@ def verify_local_dependencies(dependencies: list[Dependency]) -> bool:
 
 
 def get_non_shared_remote_dependencies(
-    service_to_stop: Service, remote_dependencies: set[InstalledRemoteDependency]
+    service_to_stop: Service,
+    remote_dependencies: set[InstalledRemoteDependency],
+    exclude_local: bool,
 ) -> set[InstalledRemoteDependency]:
     state = State()
     starting_services = set(state.get_service_entries(StateTables.STARTING_SERVICES))
@@ -291,6 +294,7 @@ def get_non_shared_remote_dependencies(
 
     active_modes: dict[str, list[str]] = dict()
     for active_service in active_services:
+        # TODO: We probably shouldn't use an OR here, but an AND
         starting_modes = state.get_active_modes_for_service(
             active_service, StateTables.STARTING_SERVICES
         )
@@ -303,9 +307,15 @@ def get_non_shared_remote_dependencies(
     base_running_service_names: set[str] = set()
     for started_service_name in active_services:
         started_service = find_matching_service(started_service_name)
-        for dependency_name in service_to_stop.config.dependencies.keys():
-            if dependency_name == started_service.config.service_name:
-                base_running_service_names.add(started_service_name)
+        started_service_runtime = state.get_service_runtime(started_service_name)
+        if exclude_local or started_service_runtime != ServiceRuntime.LOCAL:
+            # TODO: In theory, we should only be able to run the base-service when a dependent service is running if
+            # 1. the dependent service is using a mode that doesn't include the base-service
+            # 2. the base-service is using a local runtime
+            # But we don't restrict the other cases currently
+            for dependency_name in service_to_stop.config.dependencies.keys():
+                if dependency_name == started_service.config.service_name:
+                    base_running_service_names.add(started_service_name)
 
         started_service_modes = active_modes[started_service_name]
         # Only consider the dependencies of the modes that are running

{devservices-1.1.1 → devservices-1.1.2}/devservices/utils/supervisor.py

@@ -8,6 +8,8 @@ import subprocess
 import xmlrpc.client
 from enum import IntEnum
 
+from supervisor.options import ServerOptions
+
 from devservices.constants import DEVSERVICES_SUPERVISOR_CONFIG_DIR
 from devservices.exceptions import SupervisorConfigError
 from devservices.exceptions import SupervisorConnectionError
@@ -151,26 +153,36 @@ class SupervisorManager:
         except xmlrpc.client.Fault as e:
             raise SupervisorError(f"Failed to stop supervisor: {e.faultString}")
 
-    def start_program(self, program_name: str) -> None:
-        if self._is_program_running(program_name):
+    def start_process(self, name: str) -> None:
+        if self._is_program_running(name):
             return
         try:
-            self._get_rpc_client().supervisor.startProcess(program_name)
+            self._get_rpc_client().supervisor.startProcess(name)
         except xmlrpc.client.Fault as e:
             raise SupervisorProcessError(
-                f"Failed to start program {program_name}: {e.faultString}"
+                f"Failed to start process {name}: {e.faultString}"
             )
 
-    def stop_program(self, program_name: str) -> None:
-        if not self._is_program_running(program_name):
+    def stop_process(self, name: str) -> None:
+        if not self._is_program_running(name):
             return
         try:
-            self._get_rpc_client().supervisor.stopProcess(program_name)
+            self._get_rpc_client().supervisor.stopProcess(name)
         except xmlrpc.client.Fault as e:
             raise SupervisorProcessError(
-                f"Failed to stop program {program_name}: {e.faultString}"
+                f"Failed to stop process {name}: {e.faultString}"
             )
 
+    def get_program_command(self, program_name: str) -> str:
+        opts = ServerOptions()
+        opts.configfile = self.config_file_path
+        opts.process_config()
+        for group in opts.process_group_configs:
+            for proc in group.process_configs:
+                if proc.name == program_name and isinstance(proc.command, str):
+                    return proc.command
+        raise SupervisorConfigError(f"Program {program_name} not found in config")
+
     def tail_program_logs(self, program_name: str) -> None:
         if not self._is_program_running(program_name):
             console = Console()

{devservices-1.1.1 → devservices-1.1.2}/devservices.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: devservices
-Version: 1.1.1
-Requires-Python: >=3.10
+Version: 1.1.2
+Requires-Python: >=3.11
 License-File: LICENSE.md
 Requires-Dist: pyyaml
 Requires-Dist: sentry-devenv

{devservices-1.1.1 → devservices-1.1.2}/devservices.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE.md
 README.md
 pyproject.toml
 setup.cfg
+devenv/sync.py
 devservices/__init__.py
 devservices/constants.py
 devservices/exceptions.py
@@ -18,6 +19,7 @@ devservices/commands/list_dependencies.py
 devservices/commands/list_services.py
 devservices/commands/logs.py
 devservices/commands/purge.py
+devservices/commands/serve.py
 devservices/commands/status.py
 devservices/commands/toggle.py
 devservices/commands/up.py
@@ -45,6 +47,7 @@ tests/commands/test_list_dependencies.py
 tests/commands/test_list_services.py
 tests/commands/test_logs.py
 tests/commands/test_purge.py
+tests/commands/test_serve.py
 tests/commands/test_status.py
 tests/commands/test_toggle.py
 tests/commands/test_up.py

{devservices-1.1.1 → devservices-1.1.2}/devservices.egg-info/top_level.txt

@@ -1,3 +1,4 @@
+devenv
 devservices
 dist
 scripts

{devservices-1.1.1 → devservices-1.1.2}/pyproject.toml

@@ -4,9 +4,9 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devservices"
-version = "1.1.1"
-# 3.10 is just for internal pypi compat
-requires-python = ">=3.10"
+version = "1.1.2"
+# 3.11 is just for internal pypi compat
+requires-python = ">=3.11"
 dependencies = [
     "pyyaml",
     "sentry-devenv",

{devservices-1.1.1 → devservices-1.1.2}/testing/utils.py

@@ -8,6 +8,7 @@ from pathlib import Path
 import yaml
 
 from devservices.constants import DEVSERVICES_DIR_NAME
+from devservices.constants import PROGRAMS_CONF_FILE_NAME
 
 TESTING_DIR = os.path.abspath(os.path.dirname(__file__))
 
@@ -26,6 +27,14 @@ def create_config_file(
         yaml.dump(config, f, sort_keys=False, default_flow_style=False)
 
 
+def create_programs_conf_file(tmp_path: Path, config: str) -> None:
+    devservices_dir = Path(tmp_path, DEVSERVICES_DIR_NAME)
+    devservices_dir.mkdir(parents=True, exist_ok=True)
+    tmp_file = Path(devservices_dir, PROGRAMS_CONF_FILE_NAME)
+    with tmp_file.open("w") as f:
+        f.write(config)
+
+
 def run_git_command(command: list[str], cwd: Path) -> None:
     subprocess.run(
         ["git", *command], cwd=cwd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL