devservices 1.5.1__tar.gz → 1.5.4__tar.gz

{devservices-1.5.1 → devservices-1.5.4}/PKG-INFO

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

{devservices-1.5.1 → devservices-1.5.4}/README.md

@@ -33,7 +33,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.5.1
+devservices==1.5.4
 ```
 
 ### 2. Add devservices config files

{devservices-1.5.1 → devservices-1.5.4}/devservices/constants.py

@@ -22,7 +22,10 @@ class DependencyType(StrEnum):
     SUPERVISOR = "supervisor"
 
 
+# Any installed Docker Compose at or above the minimum is used as is. The install
+# version is only downloaded when Compose is missing or older than the minimum.
 MINIMUM_DOCKER_COMPOSE_VERSION = "2.29.7"
+DOCKER_COMPOSE_INSTALL_VERSION = "5.6.0"
 DEVSERVICES_DIR_NAME = "devservices"
 CONFIG_FILE_NAME = "config.yml"
 DOCKER_CONFIG_DIR = os.environ.get("DOCKER_CONFIG", os.path.expanduser("~/.docker"))
@@ -42,15 +45,13 @@ DEVSERVICES_RELEASES_URL = (
     "https://api.github.com/repos/getsentry/devservices/releases/latest"
 )
 
-# We mirror this in our GCP bucket since GitHub downloads can be flaky at times.
-# gsutil cp docker-compose-darwin-aarch64 gs://sentry-dev-infra-assets/docker-compose/v2.29.7/docker-compose-darwin-aarch64
-# gsutil cp docker-compose-linux-x86_64 gs://sentry-dev-infra-assets/docker-compose/v2.29.7/docker-compose-linux-x86_64
-DOCKER_COMPOSE_DOWNLOAD_URL = (
-    "https://storage.googleapis.com/sentry-dev-infra-assets/docker-compose"
-)
+DOCKER_COMPOSE_DOWNLOAD_URL = "https://github.com/docker/compose/releases/download"
 
 DEVSERVICES_DOWNLOAD_URL = "https://github.com/getsentry/devservices/releases/download"
 BINARY_PERMISSIONS = 0o755
+# Seconds a download may stall (connecting or between reads) before the attempt
+# is abandoned and retried.
+DOWNLOAD_TIMEOUT = 15
 MAX_LOG_LINES = "100"
 LOGGER_NAME = "devservices"
 DOCKER_NETWORK_NAME = "devservices"

{devservices-1.5.1 → devservices-1.5.4}/devservices/exceptions.py

@@ -99,7 +99,12 @@ class DependencyError(Exception):
         self.stderr = stderr
 
     def __str__(self) -> str:
-        return f"DependencyError: {self.repo_name} ({self.repo_link}) on {self.branch}"
+        message = (
+            f"DependencyError: {self.repo_name} ({self.repo_link}) on {self.branch}"
+        )
+        if self.__cause__ is not None:
+            message += f" ({type(self.__cause__).__name__}: {self.__cause__})"
+        return message
 
 
 class InvalidDependencyConfigError(DependencyError):

{devservices-1.5.1 → devservices-1.5.4}/devservices/main.py

@@ -84,6 +84,13 @@ if not disable_sentry:
             ArgvIntegration(),
             LoggingIntegration(sentry_logs_level=logging.DEBUG),
         ],
+        # By default the Sentry SDK loads integrations for all relevant libraries in
+        # the venv. When running devservices in the seer directory we end up loading
+        # Hugging Face, OpenAI, Anthropic and Celery. Likewise in sentry we end up
+        # loading Django, Redis and boto3. This is in spite of devservices not
+        # actually using those libraries. By disabling this behaviour we can reduce
+        # startup time for devservices.
+        auto_enabling_integrations=False,
         enable_logs=True,
         environment=sentry_environment,
         before_send=before_send_error,

{devservices-1.5.1 → devservices-1.5.4}/devservices/utils/dependencies.py

@@ -23,6 +23,7 @@ from devservices.constants import CONFIG_FILE_NAME
 from devservices.constants import DEPENDENCY_CONFIG_VERSION
 from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR
 from devservices.constants import DEVSERVICES_DIR_NAME
+from devservices.constants import DOWNLOAD_TIMEOUT
 from devservices.constants import DependencyType
 from devservices.exceptions import ConfigNotFoundError
 from devservices.exceptions import ConfigParseError
@@ -408,6 +409,14 @@ def install_dependency(dependency: RemoteConfig) -> set[InstalledRemoteDependenc
     return installed_dependencies
 
 
+def _is_retryable_download_error(e: BaseException) -> bool:
+    # GitHub's API intermittently returns 5xx (and 429 when throttled). Those
+    # are worth retrying; other HTTP errors (404, 401, 403) won't fix themselves.
+    if isinstance(e, urllib.error.HTTPError):
+        return e.code >= 500 or e.code == 429
+    return True
+
+
 def _fetch_dependency(
     dependency: RemoteConfig,
     dependency_repo_dir: str,
@@ -433,15 +442,18 @@ def _fetch_dependency(
 
     def _download() -> bytes:
         req = github.build_api_request(zip_url)
-        with urllib.request.urlopen(req) as response:
+        with urllib.request.urlopen(req, timeout=DOWNLOAD_TIMEOUT) as response:
             return bytes(response.read())
 
     try:
         zip_data = io.BytesIO(
             retry(
                 _download,
+                retries=5,
+                delay=1.0,
+                backoff=2.0,
                 exceptions=(OSError,),
-                should_retry=lambda e: not isinstance(e, urllib.error.HTTPError),
+                should_retry=_is_retryable_download_error,
             )
         )
     except (OSError, ValueError) as e:

{devservices-1.5.1 → devservices-1.5.4}/devservices/utils/docker_compose.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import concurrent.futures
 import json
 import logging
 import os
@@ -9,7 +10,6 @@ import shlex
 import subprocess
 import time
 from typing import NamedTuple
-from typing import cast
 
 from packaging import version
 from sentry_sdk import logger as sentry_logger
@@ -18,6 +18,7 @@ from devservices.configs.service_config import load_service_config_from_file
 from devservices.constants import CONFIG_FILE_NAME
 from devservices.constants import DEVSERVICES_DIR_NAME
 from devservices.constants import DOCKER_COMPOSE_DOWNLOAD_URL
+from devservices.constants import DOCKER_COMPOSE_INSTALL_VERSION
 from devservices.constants import DOCKER_USER_PLUGIN_DIR
 from devservices.constants import LOGGER_NAME
 from devservices.constants import MINIMUM_DOCKER_COMPOSE_VERSION
@@ -68,7 +69,7 @@ def install_docker_compose() -> None:
     else:
         raise DockerComposeInstallationError(f"Unsupported operating system: {system}")
 
-    url = f"{DOCKER_COMPOSE_DOWNLOAD_URL}/v{MINIMUM_DOCKER_COMPOSE_VERSION}/{binary_name_with_extension}"
+    url = f"{DOCKER_COMPOSE_DOWNLOAD_URL}/v{DOCKER_COMPOSE_INSTALL_VERSION}/{binary_name_with_extension}"
     destination = os.path.join(DOCKER_USER_PLUGIN_DIR, binary_name)
     os.makedirs(DOCKER_USER_PLUGIN_DIR, exist_ok=True)
 
@@ -76,14 +77,14 @@ def install_docker_compose() -> None:
         install_binary(
             binary_name,
             destination,
-            MINIMUM_DOCKER_COMPOSE_VERSION,
+            DOCKER_COMPOSE_INSTALL_VERSION,
             url,
         )
     except BinaryInstallError as e:
         raise DockerComposeInstallationError(f"Failed to install Docker Compose: {e}")
 
     console.success(
-        f"Docker Compose {MINIMUM_DOCKER_COMPOSE_VERSION} installed successfully to {destination}"
+        f"Docker Compose {DOCKER_COMPOSE_INSTALL_VERSION} installed successfully to {destination}"
     )
 
     # Verify the installation
@@ -137,42 +138,25 @@ def check_docker_compose_version() -> None:
     # Throw an error if docker daemon isn't running
     check_docker_daemon_running()
     try:
-        # Run the docker compose version command
-        docker_compose_version = get_docker_compose_version()
+        version_output = get_docker_compose_version()
     except DockerComposeError:
-        docker_compose_version = None
         console.warning(
-            f"Docker Compose is not installed, attempting to install v{MINIMUM_DOCKER_COMPOSE_VERSION}"
+            f"Docker Compose is not installed, attempting to install v{DOCKER_COMPOSE_INSTALL_VERSION}"
         )
+        install_docker_compose()
+        return
 
-    # Extract the version number from the output
-    version_output = (
-        docker_compose_version if docker_compose_version is not None else ""
-    )
-
-    # Use regex to find the version number
-    pattern = r"^(\d+\.\d+\.\d+)"
-
-    match = re.search(pattern, version_output)
-    if match:
-        # There is a chance that Any type is returned, so cast this
-        docker_compose_version = cast(str, match.group(1))
-    else:
-        docker_compose_version = None
-
-    if docker_compose_version is None:
+    # Docker Desktop reports versions like "2.29.7-desktop.1", so only match the prefix
+    match = re.search(r"^(\d+\.\d+\.\d+)", version_output)
+    if match is None:
         console.warning(
-            f"Unable to detect Docker Compose version, attempting to install v{MINIMUM_DOCKER_COMPOSE_VERSION}"
+            f"Unable to detect Docker Compose version, attempting to install v{DOCKER_COMPOSE_INSTALL_VERSION}"
         )
-    elif version.parse(docker_compose_version) != version.parse(
-        MINIMUM_DOCKER_COMPOSE_VERSION
-    ):
+    elif version.parse(match.group(1)) < version.parse(MINIMUM_DOCKER_COMPOSE_VERSION):
         console.warning(
-            f"Docker Compose version v{docker_compose_version} unsupported, attempting to install v{MINIMUM_DOCKER_COMPOSE_VERSION}"
+            f"Docker Compose v{match.group(1)} is older than the minimum supported v{MINIMUM_DOCKER_COMPOSE_VERSION}, attempting to install v{DOCKER_COMPOSE_INSTALL_VERSION}"
         )
-    elif version.parse(docker_compose_version) == version.parse(
-        MINIMUM_DOCKER_COMPOSE_VERSION
-    ):
+    else:
         return
     install_docker_compose()
 
@@ -254,17 +238,25 @@ def get_docker_compose_commands_to_run(
     service_config_file_path: str,
     mode_dependencies: list[str],
 ) -> list[DockerComposeCommand]:
+    dependency_config_paths = [
+        os.path.join(dependency.repo_path, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME)
+        for dependency in remote_dependencies
+    ]
+
+    # Each lookup shells out to `docker compose config`, so run them concurrently
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        *dependency_non_remote_services, non_remote_services = executor.map(
+            lambda config_path: get_non_remote_services(config_path, current_env),
+            [*dependency_config_paths, service_config_file_path],
+        )
+
     docker_compose_commands = []
-    for dependency in remote_dependencies:
+    for dependency, dependency_config_path, dependency_services in zip(
+        remote_dependencies, dependency_config_paths, dependency_non_remote_services
+    ):
         # TODO: Consider passing in service config in InstalledRemoteDependency instead of loading it here
         dependency_service_config = load_service_config_from_file(dependency.repo_path)
-        dependency_config_path = os.path.join(
-            dependency.repo_path, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME
-        )
-        non_remote_services = get_non_remote_services(
-            dependency_config_path, current_env
-        )
-        services_to_use = non_remote_services.intersection(
+        services_to_use = dependency_services.intersection(
             set(dependency_service_config.modes[dependency.mode])
         )
         docker_compose_commands.append(
@@ -278,7 +270,6 @@ def get_docker_compose_commands_to_run(
         )
 
     # Add docker compose command for the top level service
-    non_remote_services = get_non_remote_services(service_config_file_path, current_env)
     services_to_use = non_remote_services.intersection(set(mode_dependencies))
     if len(services_to_use) > 0:
         docker_compose_commands.append(

{devservices-1.5.1 → devservices-1.5.4}/devservices/utils/install_binary.py

@@ -3,13 +3,23 @@ from __future__ import annotations
 import os
 import shutil
 import tempfile
-from urllib.request import urlretrieve
+from urllib.request import urlopen
 
 from devservices.constants import BINARY_PERMISSIONS
+from devservices.constants import DOWNLOAD_TIMEOUT
 from devservices.exceptions import BinaryInstallError
 from devservices.utils.console import Console
 from devservices.utils.retry import retry
 
+DOWNLOAD_ATTEMPTS = 3
+
+
+def download_file(url: str, path: str) -> None:
+    # urlretrieve has no timeout, so a stalled connection would hang forever.
+    # The timeout applies to connecting and to each read, not the whole download.
+    with urlopen(url, timeout=DOWNLOAD_TIMEOUT) as response, open(path, "wb") as f:
+        shutil.copyfileobj(response, f)
+
 
 def install_binary(
     binary_name: str,
@@ -24,16 +34,17 @@ def install_binary(
         console.info(f"Downloading {binary_name} {version} from {url}...")
         try:
             retry(
-                lambda: urlretrieve(url, temp_file),
-                retries=3,
+                lambda: download_file(url, temp_file),
+                retries=DOWNLOAD_ATTEMPTS,
                 delay=1.0,
+                backoff=2.0,
                 on_retry=lambda e, remaining: console.warning(
-                    f"Download failed. Retrying in 1 seconds... ({remaining} retries left)"
+                    f"Download failed ({e}). Retrying... ({remaining} retries left)"
                 ),
             )
         except Exception as e:
             raise BinaryInstallError(
-                f"Failed to download {binary_name} after 3 attempts: {e}"
+                f"Failed to download {binary_name} after {DOWNLOAD_ATTEMPTS} attempts: {e}"
             ) from e
 
         try:

{devservices-1.5.1 → devservices-1.5.4}/devservices/utils/retry.py

@@ -12,6 +12,7 @@ def retry(
     *,
     retries: int = 3,
     delay: float = 1.0,
+    backoff: float = 1.0,
     exceptions: tuple[type[BaseException], ...] = (Exception,),
     on_retry: Callable[[BaseException, int], None] | None = None,
     should_retry: Callable[[BaseException], bool] | None = None,
@@ -23,7 +24,8 @@ def retry(
     Args:
         fn: Callable to invoke.
         retries: Total number of attempts (must be >= 1).
-        delay: Seconds to sleep between attempts.
+        delay: Seconds to sleep before the first retry.
+        backoff: Multiplier applied to the delay after each retry.
         exceptions: Exception types that trigger a retry.
         on_retry: Optional callback(exc, attempts_remaining) invoked before each sleep.
         should_retry: Optional predicate; if it returns False the exception is re-raised
@@ -41,5 +43,5 @@ def retry(
                 raise
             if on_retry is not None:
                 on_retry(e, retries - attempt - 1)
-            time.sleep(delay)
+            time.sleep(delay * backoff**attempt)
     raise AssertionError("unreachable")

{devservices-1.5.1 → devservices-1.5.4}/devservices.egg-info/PKG-INFO

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

{devservices-1.5.1 → devservices-1.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devservices"
-version = "1.5.1"
+version = "1.5.4"
 # 3.11 is just for internal pypi compat
 # but we test/support on 3.13
 requires-python = ">=3.11"

{devservices-1.5.1 → devservices-1.5.4}/testing/utils.py

@@ -69,10 +69,10 @@ def make_urlopen_response(zip_bytes: bytes) -> mock.MagicMock:
 
 def url_dispatch(
     zip_bytes_by_repo_name: dict[str, bytes],
-) -> Callable[[mock.MagicMock], mock.MagicMock]:
+) -> Callable[..., mock.MagicMock]:
     """Return a urlopen side_effect that routes requests by repo name in the URL."""
 
-    def _side_effect(request: mock.MagicMock) -> mock.MagicMock:
+    def _side_effect(request: mock.MagicMock, timeout: float) -> mock.MagicMock:
         url = request.full_url
         for repo_name, zip_bytes in zip_bytes_by_repo_name.items():
             if f"/{repo_name}/" in url:

{devservices-1.5.1 → devservices-1.5.4}/tests/utils/test_dependencies.py

@@ -106,7 +106,7 @@ def test_fetch_dependency_network_error(tmp_path: Path) -> None:
         _fetch_dependency(dep, str(tmp_path / "dest"))
 
 
-def test_fetch_dependency_http_error_not_retried(tmp_path: Path) -> None:
+def test_fetch_dependency_client_error_not_retried(tmp_path: Path) -> None:
     dep = RemoteConfig(
         repo_name="test-repo",
         branch="main",
@@ -125,10 +125,75 @@ def test_fetch_dependency_http_error_not_retried(tmp_path: Path) -> None:
     )
     with urlopen_mock as mock_urlopen, pytest.raises(DependencyError):
         _fetch_dependency(dep, str(tmp_path / "dest"))
-    # HTTP errors must not be retried, so urlopen is only ever called once.
+    # Client errors won't fix themselves, so urlopen is only ever called once.
     mock_urlopen.assert_called_once()
 
 
+def _http_error(code: int, msg: str) -> urllib.error.HTTPError:
+    return urllib.error.HTTPError(
+        url="https://api.github.com/repos/getsentry/test-repo/zipball/main",
+        code=code,
+        msg=msg,
+        hdrs=None,  # type: ignore[arg-type]
+        fp=None,
+    )
+
+
+@pytest.mark.parametrize(
+    ("code", "msg"),
+    [(500, "Internal Server Error"), (503, "Service Unavailable"), (429, "Too Many")],
+)
+def test_fetch_dependency_retries_transient_http_error(
+    tmp_path: Path, code: int, msg: str
+) -> None:
+    dep = RemoteConfig(
+        repo_name="test-repo",
+        branch="main",
+        repo_link="https://github.com/getsentry/test-repo",
+    )
+    zip_bytes = _make_zip_bytes(BASIC_SERVICE_CONFIG)
+    dest = str(tmp_path / "dest")
+    with (
+        mock.patch("devservices.utils.retry.time.sleep") as mock_sleep,
+        mock.patch(
+            "devservices.utils.dependencies.urllib.request.urlopen",
+            side_effect=[
+                _http_error(code, msg),
+                _http_error(code, msg),
+                _make_urlopen_response(zip_bytes),
+            ],
+        ) as mock_urlopen,
+    ):
+        _fetch_dependency(dep, dest)
+    assert mock_urlopen.call_count == 3
+    assert [c.args[0] for c in mock_sleep.call_args_list] == [1.0, 2.0]
+    assert (Path(dest) / DEVSERVICES_DIR_NAME / CONFIG_FILE_NAME).exists()
+
+
+def test_fetch_dependency_server_error_exhausts_retries(tmp_path: Path) -> None:
+    dep = RemoteConfig(
+        repo_name="test-repo",
+        branch="main",
+        repo_link="https://github.com/getsentry/test-repo",
+    )
+    with (
+        mock.patch("devservices.utils.retry.time.sleep") as mock_sleep,
+        mock.patch(
+            "devservices.utils.dependencies.urllib.request.urlopen",
+            side_effect=_http_error(500, "Internal Server Error"),
+        ) as mock_urlopen,
+        pytest.raises(DependencyError) as exc_info,
+    ):
+        _fetch_dependency(dep, str(tmp_path / "dest"))
+    assert mock_urlopen.call_count == 5
+    assert [c.args[0] for c in mock_sleep.call_args_list] == [1.0, 2.0, 4.0, 8.0]
+    # The underlying cause is surfaced so CI logs show what actually failed.
+    assert str(exc_info.value) == (
+        "DependencyError: test-repo (https://github.com/getsentry/test-repo) on main "
+        "(HTTPError: HTTP Error 500: Internal Server Error)"
+    )
+
+
 def test_fetch_dependency_read_error(tmp_path: Path) -> None:
     dep = RemoteConfig(
         repo_name="test-repo",

{devservices-1.5.1 → devservices-1.5.4}/tests/utils/test_docker_compose.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import os
 import subprocess
+from collections.abc import Callable
 from pathlib import Path
 from unittest import mock
 
@@ -10,6 +11,7 @@ import pytest
 from devservices.configs.service_config import load_service_config_from_file
 from devservices.constants import CONFIG_FILE_NAME
 from devservices.constants import DEVSERVICES_DIR_NAME
+from devservices.constants import MINIMUM_DOCKER_COMPOSE_VERSION
 from devservices.exceptions import BinaryInstallError
 from devservices.exceptions import DockerComposeError
 from devservices.exceptions import DockerComposeInstallationError
@@ -27,10 +29,29 @@ from devservices.utils.services import Service
 from testing.utils import create_mock_git_repo
 
 
+def mock_docker_compose_config_services(
+    services_by_repo_path: dict[str, str],
+) -> Callable[..., subprocess.CompletedProcess[str]]:
+    def _run(
+        cmd: list[str], *args: object, **kwargs: object
+    ) -> subprocess.CompletedProcess[str]:
+        config_path = cmd[cmd.index("-f") + 1]
+        repo_path = os.path.dirname(os.path.dirname(config_path))
+        return subprocess.CompletedProcess(
+            args=cmd, returncode=0, stdout=services_by_repo_path[repo_path]
+        )
+
+    return _run
+
+
 @mock.patch("subprocess.run")
-def test_check_docker_compose_version_success(mock_run: mock.Mock) -> None:
-    mock_run.return_value.stdout = "2.29.7\n"
+@mock.patch("devservices.utils.docker_compose.install_docker_compose")
+def test_check_docker_compose_version_success(
+    mock_install_docker_compose: mock.Mock, mock_run: mock.Mock
+) -> None:
+    mock_run.return_value.stdout = f"{MINIMUM_DOCKER_COMPOSE_VERSION}\n"
     check_docker_compose_version()  # Should not raise any exception
+    mock_install_docker_compose.assert_not_called()
 
 
 @mock.patch("subprocess.run")
@@ -62,7 +83,33 @@ def test_check_docker_compose_version_unsupported(
 ) -> None:
     mock_run.return_value.stdout = "2.20.0-desktop.1\n"
     check_docker_compose_version()
-    assert mock_install_docker_compose.is_called()
+    mock_install_docker_compose.assert_called_once()
+
+
+@pytest.mark.parametrize(
+    "installed_version",
+    ["2.29.7", "2.29.7-desktop.1", "2.38.2", "2.40.3-desktop.1", "5.6.0", "6.0.0"],
+)
+@mock.patch("subprocess.run")
+@mock.patch("devservices.utils.docker_compose.install_docker_compose")
+def test_check_docker_compose_version_at_or_above_minimum(
+    mock_install_docker_compose: mock.Mock,
+    mock_run: mock.Mock,
+    installed_version: str,
+) -> None:
+    mock_run.return_value.stdout = f"{installed_version}\n"
+    check_docker_compose_version()
+    mock_install_docker_compose.assert_not_called()
+
+
+@mock.patch("subprocess.run")
+@mock.patch("devservices.utils.docker_compose.install_docker_compose")
+def test_check_docker_compose_version_below_minimum(
+    mock_install_docker_compose: mock.Mock, mock_run: mock.Mock
+) -> None:
+    mock_run.return_value.stdout = "2.29.6\n"
+    check_docker_compose_version()
+    mock_install_docker_compose.assert_called_once()
 
 
 @mock.patch("subprocess.run")
@@ -170,7 +217,7 @@ def test_install_docker_compose_binary_install_error(
 
 @mock.patch("platform.system", return_value="Darwin")
 @mock.patch("platform.machine", return_value="arm64")
-@mock.patch("devservices.utils.install_binary.urlretrieve")
+@mock.patch("devservices.utils.install_binary.download_file")
 @mock.patch("devservices.utils.install_binary.os.chmod")
 @mock.patch("devservices.utils.install_binary.shutil.move")
 @mock.patch(
@@ -186,7 +233,7 @@ def test_install_docker_compose_compose_verification_error(
     _mock_get_docker_compose_version: mock.Mock,
     _mock_shutil_move: mock.Mock,
     _mock_chmod: mock.Mock,
-    _mock_urlretrieve: mock.Mock,
+    _mock_download_file: mock.Mock,
     _mock_machine: mock.Mock,
     _mock_system: mock.Mock,
 ) -> None:
@@ -200,26 +247,26 @@ def test_install_docker_compose_compose_verification_error(
 @mock.patch("devservices.utils.install_binary.tempfile.TemporaryDirectory")
 @mock.patch("platform.system", return_value="Darwin")
 @mock.patch("platform.machine", return_value="arm64")
-@mock.patch("devservices.utils.install_binary.urlretrieve")
+@mock.patch("devservices.utils.install_binary.download_file")
 @mock.patch("devservices.utils.install_binary.os.chmod")
 @mock.patch("devservices.utils.install_binary.shutil.move")
 @mock.patch(
     "devservices.utils.docker_compose.get_docker_compose_version",
-    return_value="2.29.7\n",
+    return_value="5.6.0\n",
 )
 def test_install_docker_compose_macos_arm64(
     mock_get_docker_compose_version: mock.Mock,
     mock_shutil_move: mock.Mock,
     mock_chmod: mock.Mock,
-    mock_urlretrieve: mock.Mock,
+    mock_download_file: mock.Mock,
     _mock_machine: mock.Mock,
     _mock_system: mock.Mock,
     mock_tempdir: mock.Mock,
 ) -> None:
     mock_tempdir.return_value.__enter__.return_value = "tempdir"
     install_docker_compose()
-    mock_urlretrieve.assert_called_once_with(
-        "https://storage.googleapis.com/sentry-dev-infra-assets/docker-compose/v2.29.7/docker-compose-darwin-aarch64",
+    mock_download_file.assert_called_once_with(
+        "https://github.com/docker/compose/releases/download/v5.6.0/docker-compose-darwin-aarch64",
         "tempdir/docker-compose",
     )
     mock_chmod.assert_called_once_with("tempdir/docker-compose", 0o755)
@@ -233,26 +280,26 @@ def test_install_docker_compose_macos_arm64(
 @mock.patch("devservices.utils.install_binary.tempfile.TemporaryDirectory")
 @mock.patch("platform.system", return_value="Linux")
 @mock.patch("platform.machine", return_value="x86_64")
-@mock.patch("devservices.utils.install_binary.urlretrieve")
+@mock.patch("devservices.utils.install_binary.download_file")
 @mock.patch("devservices.utils.install_binary.os.chmod")
 @mock.patch("devservices.utils.install_binary.shutil.move")
 @mock.patch(
     "devservices.utils.docker_compose.get_docker_compose_version",
-    return_value="2.29.7\n",
+    return_value="5.6.0\n",
 )
 def test_install_docker_compose_linux_x86(
     mock_get_docker_compose_version: mock.Mock,
     mock_shutil_move: mock.Mock,
     mock_chmod: mock.Mock,
-    mock_urlretrieve: mock.Mock,
+    mock_download_file: mock.Mock,
     _mock_machine: mock.Mock,
     _mock_system: mock.Mock,
     mock_tempdir: mock.Mock,
 ) -> None:
     mock_tempdir.return_value.__enter__.return_value = "tempdir"
     install_docker_compose()
-    mock_urlretrieve.assert_called_once_with(
-        "https://storage.googleapis.com/sentry-dev-infra-assets/docker-compose/v2.29.7/docker-compose-linux-x86_64",
+    mock_download_file.assert_called_once_with(
+        "https://github.com/docker/compose/releases/download/v5.6.0/docker-compose-linux-x86_64",
         "tempdir/docker-compose",
     )
     mock_chmod.assert_called_once_with("tempdir/docker-compose", 0o755)
@@ -266,18 +313,18 @@ def test_install_docker_compose_linux_x86(
 @mock.patch("devservices.utils.install_binary.tempfile.TemporaryDirectory")
 @mock.patch("platform.system", return_value="Darwin")
 @mock.patch("platform.machine", return_value="arm64")
-@mock.patch("devservices.utils.install_binary.urlretrieve")
+@mock.patch("devservices.utils.install_binary.download_file")
 @mock.patch("devservices.utils.install_binary.os.chmod")
 @mock.patch("devservices.utils.install_binary.shutil.move")
 @mock.patch(
     "devservices.utils.docker_compose.get_docker_compose_version",
-    return_value="2.29.7\n",
+    return_value="5.6.0\n",
 )
 def test_install_docker_compose_custom_docker_config_dir(
     mock_get_docker_compose_version: mock.Mock,
     mock_shutil_move: mock.Mock,
     mock_chmod: mock.Mock,
-    mock_urlretrieve: mock.Mock,
+    mock_download_file: mock.Mock,
     _mock_machine: mock.Mock,
     _mock_system: mock.Mock,
     mock_tempdir: mock.Mock,
@@ -288,8 +335,8 @@ def test_install_docker_compose_custom_docker_config_dir(
         "tempdir/docker/config/cli-plugins",
     ):
         install_docker_compose()
-    mock_urlretrieve.assert_called_once_with(
-        "https://storage.googleapis.com/sentry-dev-infra-assets/docker-compose/v2.29.7/docker-compose-darwin-aarch64",
+    mock_download_file.assert_called_once_with(
+        "https://github.com/docker/compose/releases/download/v5.6.0/docker-compose-darwin-aarch64",
         "tempdir/docker-compose",
     )
     mock_chmod.assert_called_once_with("tempdir/docker-compose", 0o755)
@@ -452,18 +499,12 @@ def test_get_all_commands_to_run_simple_remote(
         parent_service_repo_path, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME
     )
     mode_dependencies = service_config.modes["default"]
-    mock_run.side_effect = [
-        subprocess.CompletedProcess(
-            args=["docker", "compose", "config", "--services"],
-            returncode=0,
-            stdout="child-service\n",
-        ),
-        subprocess.CompletedProcess(
-            args=["docker", "compose", "config", "--services"],
-            returncode=0,
-            stdout="parent-service\n",
-        ),
-    ]
+    mock_run.side_effect = mock_docker_compose_config_services(
+        {
+            child_service_repo_path_str: "child-service\n",
+            parent_service_repo_path_str: "parent-service\n",
+        }
+    )
     commands = get_docker_compose_commands_to_run(
         service=service,
         remote_dependencies=remote_dependencies,
@@ -555,23 +596,13 @@ def test_get_all_commands_to_run_complex_remote(
         grandparent_service_repo_path_str, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME
     )
     mode_dependencies = service_config.modes["default"]
-    mock_run.side_effect = [
-        subprocess.CompletedProcess(
-            args=["docker", "compose", "config", "--services"],
-            returncode=0,
-            stdout="child-service\n",
-        ),
-        subprocess.CompletedProcess(
-            args=["docker", "compose", "config", "--services"],
-            returncode=0,
-            stdout="parent-service\n",
-        ),
-        subprocess.CompletedProcess(
-            args=["docker", "compose", "config", "--services"],
-            returncode=0,
-            stdout="grandparent-service\n",
-        ),
-    ]
+    mock_run.side_effect = mock_docker_compose_config_services(
+        {
+            child_service_repo_path_str: "child-service\n",
+            parent_service_repo_path_str: "parent-service\n",
+            grandparent_service_repo_path_str: "grandparent-service\n",
+        }
+    )
     commands = get_docker_compose_commands_to_run(
         service=service,
         remote_dependencies=list(remote_dependencies),
@@ -685,23 +716,13 @@ def test_get_all_commands_to_run_complex_shared_dependency(
         grandparent_service_repo_path_str, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME
     )
     mode_dependencies = service_config.modes["default"]
-    mock_run.side_effect = [
-        subprocess.CompletedProcess(
-            args=["docker", "compose", "config", "--services"],
-            returncode=0,
-            stdout="child-service\n",
-        ),
-        subprocess.CompletedProcess(
-            args=["docker", "compose", "config", "--services"],
-            returncode=0,
-            stdout="parent-service\n",
-        ),
-        subprocess.CompletedProcess(
-            args=["docker", "compose", "config", "--services"],
-            returncode=0,
-            stdout="grandparent-service\n",
-        ),
-    ]
+    mock_run.side_effect = mock_docker_compose_config_services(
+        {
+            child_service_repo_path_str: "child-service\n",
+            parent_service_repo_path_str: "parent-service\n",
+            grandparent_service_repo_path_str: "grandparent-service\n",
+        }
+    )
     commands = get_docker_compose_commands_to_run(
         service=service,
         remote_dependencies=remote_dependencies,

{devservices-1.5.1 → devservices-1.5.4}/tests/utils/test_install_binary.py

@@ -1,19 +1,23 @@
 from __future__ import annotations
 
+import io
+import pathlib
 from unittest import mock
 
 import pytest
 
+from devservices.constants import DOWNLOAD_TIMEOUT
 from devservices.exceptions import BinaryInstallError
+from devservices.utils.install_binary import download_file
 from devservices.utils.install_binary import install_binary
 
 
 @mock.patch(
-    "devservices.utils.install_binary.urlretrieve",
+    "devservices.utils.install_binary.download_file",
     side_effect=Exception("Connection error"),
 )
 def test_install_docker_compose_connection_error(
-    mock_urlretrieve: mock.Mock, capsys: pytest.CaptureFixture[str]
+    mock_download_file: mock.Mock, capsys: pytest.CaptureFixture[str]
 ) -> None:
     with pytest.raises(
         BinaryInstallError,
@@ -33,9 +37,9 @@ def test_install_docker_compose_connection_error(
         assert "Download failed. Retrying in 1 seconds... (Attempt 2/2)" in captured.out
 
 
-@mock.patch("devservices.utils.install_binary.urlretrieve")
+@mock.patch("devservices.utils.install_binary.download_file")
 def test_install_docker_compose_chmod_file_not_found_error(
-    mock_urlretrieve: mock.Mock,
+    mock_download_file: mock.Mock,
 ) -> None:
     with pytest.raises(
         BinaryInstallError,
@@ -49,11 +53,11 @@ def test_install_docker_compose_chmod_file_not_found_error(
         )
 
 
-@mock.patch("devservices.utils.install_binary.urlretrieve")
+@mock.patch("devservices.utils.install_binary.download_file")
 @mock.patch("devservices.utils.install_binary.os.chmod")
 def test_install_docker_compose_shutil_file_not_found_error(
     mock_chmod: mock.Mock,
-    mock_urlretrieve: mock.Mock,
+    mock_download_file: mock.Mock,
 ) -> None:
     with pytest.raises(
         BinaryInstallError,
@@ -67,14 +71,14 @@ def test_install_docker_compose_shutil_file_not_found_error(
         )
 
 
-@mock.patch("devservices.utils.install_binary.urlretrieve")
+@mock.patch("devservices.utils.install_binary.download_file")
 @mock.patch(
     "devservices.utils.install_binary.os.chmod",
     side_effect=PermissionError("Insufficient Permissions"),
 )
 def test_install_docker_compose_chmod_permission_error(
     mock_chmod: mock.Mock,
-    mock_urlretrieve: mock.Mock,
+    mock_download_file: mock.Mock,
 ) -> None:
     with pytest.raises(
         BinaryInstallError,
@@ -88,7 +92,7 @@ def test_install_docker_compose_chmod_permission_error(
         )
 
 
-@mock.patch("devservices.utils.install_binary.urlretrieve")
+@mock.patch("devservices.utils.install_binary.download_file")
 @mock.patch("devservices.utils.install_binary.os.chmod")
 @mock.patch(
     "devservices.utils.install_binary.shutil.move",
@@ -96,7 +100,7 @@ def test_install_docker_compose_chmod_permission_error(
 )
 def test_install_docker_compose_shutil_move_permission_error(
     mock_chmod: mock.Mock,
-    mock_urlretrieve: mock.Mock,
+    mock_download_file: mock.Mock,
     mock_move: mock.Mock,
 ) -> None:
     with pytest.raises(
@@ -109,3 +113,45 @@ def test_install_docker_compose_shutil_move_permission_error(
             "1.0.0",
             "http:://example.com",
         )
+
+
+@mock.patch("devservices.utils.install_binary.urlopen")
+def test_download_file_uses_timeout(
+    mock_urlopen: mock.Mock, tmp_path: pathlib.Path
+) -> None:
+    mock_urlopen.return_value.__enter__.return_value = io.BytesIO(b"binary")
+    path = tmp_path / "binary-name"
+
+    download_file("https://example.com/binary", str(path))
+
+    mock_urlopen.assert_called_once_with(
+        "https://example.com/binary", timeout=DOWNLOAD_TIMEOUT
+    )
+    assert path.read_bytes() == b"binary"
+
+
+@mock.patch("devservices.utils.retry.time.sleep")
+@mock.patch(
+    "devservices.utils.install_binary.download_file",
+    side_effect=[TimeoutError("timed out"), None],
+)
+@mock.patch("devservices.utils.install_binary.os.chmod")
+@mock.patch("devservices.utils.install_binary.shutil.move")
+def test_install_binary_retries_stalled_download(
+    mock_move: mock.Mock,
+    mock_chmod: mock.Mock,
+    mock_download_file: mock.Mock,
+    mock_sleep: mock.Mock,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    install_binary(
+        "binary-name",
+        "exec_path",
+        "1.0.0",
+        "https://example.com/binary",
+    )
+
+    assert mock_download_file.call_count == 2
+    mock_sleep.assert_called_once_with(1.0)
+    mock_move.assert_called_once()
+    assert "Download failed (timed out)" in capsys.readouterr().out