Share a session, cache versions, parallel downloads

Author: elopez

solc_select/repositories.py

@@ -21,15 +21,15 @@
     EARLIEST_RELEASE,
     LINUX_AMD64,
 )
-from .infrastructure.http_client import create_http_session
 from .models import Platform, SolcVersion
 
 
 class AbstractSolcRepository(ABC):
     """Abstract base class for Solidity compiler repositories."""
 
-    def __init__(self) -> None:
-        self.session = create_http_session()
+    def __init__(self, session: requests.Session) -> None:
+        self.session = session
+        self._versions_cache: Optional[Dict[str, str]] = None
 
     @property
     @abstractmethod
@@ -45,10 +45,17 @@ def list_url(self) -> str:
 
     def get_available_versions(self) -> Dict[str, str]:
         """Get available versions as a dict of version -> artifact_filename."""
+        # Return cached data if available
+        if self._versions_cache is not None:
+            return self._versions_cache
+
+        # Fetch from network and cache
         response = self.session.get(self.list_url)
         response.raise_for_status()
         all_releases = response.json()["releases"]
-        return self._filter_versions(all_releases)
+        filtered_versions = self._filter_versions(all_releases)
+        self._versions_cache = filtered_versions
+        return filtered_versions
 
     def _filter_versions(self, releases: Dict[str, str]) -> Dict[str, str]:
         """Filter versions based on repository-specific criteria.
@@ -94,12 +101,13 @@ def supports_version(self, version: SolcVersion, platform: Platform) -> bool:
 class SoliditylangRepository(AbstractSolcRepository):
     """Repository for binaries.soliditylang.org - the main Solidity releases."""
 
-    def __init__(self, platform: Platform) -> None:
-        super().__init__()
+    def __init__(self, platform: Platform, session: requests.Session) -> None:
+        super().__init__(session)
         self.platform = platform
         platform_key = platform.get_soliditylang_key()
         self._base_url = f"https://binaries.soliditylang.org/{platform_key}/"
         self._list_url = f"https://binaries.soliditylang.org/{platform_key}/list.json"
+        self._latest_cache: Optional[SolcVersion] = None
 
     @property
     def base_url(self) -> str:
@@ -115,17 +123,24 @@ def supports_version(self, version: SolcVersion, platform: Platform) -> bool:
 
     def get_latest_version(self) -> SolcVersion:
         """Get the latest available version."""
+        # Return cached data if available
+        if self._latest_cache is not None:
+            return self._latest_cache
+
+        # Fetch from network and cache
         response = self.session.get(self.list_url)
         response.raise_for_status()
         latest_str = response.json()["latestRelease"]
-        return SolcVersion.parse(latest_str)
+        latest_version = SolcVersion.parse(latest_str)
+        self._latest_cache = latest_version
+        return latest_version
 
 
 class CryticRepository(AbstractSolcRepository):
     """Repository for crytic/solc - provides additional Linux versions."""
 
-    def __init__(self) -> None:
-        super().__init__()
+    def __init__(self, session: requests.Session) -> None:
+        super().__init__(session)
 
     @property
     def base_url(self) -> str:
@@ -153,8 +168,8 @@ def supports_version(self, version: SolcVersion, platform: Platform) -> bool:
 class AlloyRepository(AbstractSolcRepository):
     """Repository for alloy-rs/solc-builds - provides native ARM64 Darwin binaries."""
 
-    def __init__(self) -> None:
-        super().__init__()
+    def __init__(self, session: requests.Session) -> None:
+        super().__init__(session)
 
     @property
     def base_url(self) -> str:
@@ -190,19 +205,19 @@ def supports_version(self, version: SolcVersion, platform: Platform) -> bool:
 class CompositeRepository:
     """Composite repository that manages multiple underlying repositories."""
 
-    def __init__(self, platform: Platform):
+    def __init__(self, platform: Platform, session: requests.Session):
         self.platform = platform
         self.repositories: List[AbstractSolcRepository] = []
 
         # Always include the main soliditylang repository
-        self.repositories.append(SoliditylangRepository(platform))
+        self.repositories.append(SoliditylangRepository(platform, session))
 
         # Add platform-specific repositories
         if platform.get_soliditylang_key() == LINUX_AMD64:
-            self.repositories.append(CryticRepository())
+            self.repositories.append(CryticRepository(session))
 
         if platform.os_type == "darwin" and platform.architecture == "arm64":
-            self.repositories.append(AlloyRepository())
+            self.repositories.append(AlloyRepository(session))
 
     def get_available_versions(self) -> Dict[str, str]:
         """Get all available versions from all repositories."""

solc_select/services/artifact_manager.py

@@ -7,28 +7,31 @@
 
 import hashlib
 import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from functools import partial
 from io import BufferedRandom
 from pathlib import Path
 from typing import List
 from zipfile import ZipFile
 
+import requests
 from Crypto.Hash import keccak
 
 from ..constants import ARTIFACTS_DIR
 from ..exceptions import ChecksumMismatchError, SolcSelectError
-from ..infrastructure.http_client import create_http_session
 from ..models import Platform, SolcArtifact, SolcVersion
 from ..repositories import CompositeRepository
 
 
 class ArtifactManager:
     """Service for managing Solidity compiler artifacts."""
 
-    def __init__(self, repository: CompositeRepository, platform: Platform):
+    def __init__(
+        self, repository: CompositeRepository, platform: Platform, session: requests.Session
+    ):
         self.repository = repository
         self.platform = platform
-        self.session = create_http_session()
+        self.session = session
 
     def get_installed_versions(self) -> List[SolcVersion]:
         """Get list of installed versions.
@@ -193,13 +196,20 @@ def download_and_install(self, version: SolcVersion, silent: bool = False) -> bo
 
         try:
             # Download the file
-            response = self.session.get(artifact.download_url)
+            response = self.session.get(artifact.download_url, stream=True)
             response.raise_for_status()
 
             # Write and verify the file
             with open(artifact.file_path, "w+b", opener=partial(os.open, mode=0o664)) as f:
-                for chunk in response.iter_content(chunk_size=8192):
-                    f.write(chunk)
+                try:
+                    for chunk in response.iter_content(chunk_size=8192):
+                        if chunk:  # Filter out keep-alive chunks
+                            f.write(chunk)
+                except KeyboardInterrupt:
+                    # Clean up partially downloaded file on interrupt
+                    if artifact.file_path.exists():
+                        artifact.file_path.unlink(missing_ok=True)
+                    raise
 
                 # Verify checksums
                 self.verify_checksum(artifact, f)
@@ -250,7 +260,7 @@ def _extract_zip_archive(self, artifact: SolcArtifact) -> None:
         artifact.file_path.chmod(0o775)
 
     def install_versions(self, versions: List[SolcVersion], silent: bool = False) -> bool:
-        """Install multiple versions.
+        """Install multiple versions concurrently.
 
         Args:
             versions: List of versions to install
@@ -259,15 +269,76 @@ def install_versions(self, versions: List[SolcVersion], silent: bool = False) ->
         Returns:
             True if all installations succeeded, False otherwise
         """
-        success = True
+        if not versions:
+            return True
 
-        for version in versions:
+        # For single version, use sequential approach
+        if len(versions) == 1:
             try:
-                if not self.download_and_install(version, silent):
-                    success = False
+                return self.download_and_install(versions[0], silent)
             except SolcSelectError as e:
                 if not silent:
                     print(f"Error: {e}")
-                success = False
+                return False
+
+        # For multiple versions, use parallel approach
+        if not silent:
+            print(f"Installing {len(versions)} versions concurrently...")
+
+        success_count = 0
+        total_count = len(versions)
+
+        # Use ThreadPoolExecutor with max 5 concurrent downloads
+        executor = ThreadPoolExecutor(max_workers=5)
+        future_to_version = {}
+
+        try:
+            # Submit all download jobs
+            future_to_version = {
+                executor.submit(self.download_and_install, version, True): version
+                for version in versions
+            }
+
+            # Process completed downloads
+            for future in as_completed(future_to_version):
+                version = future_to_version[future]
+                try:
+                    result = future.result()
+                    if result:
+                        success_count += 1
+                        if not silent:
+                            print(
+                                f"✓ Version '{version}' installed ({success_count}/{total_count})"
+                            )
+                    elif not silent:
+                        print(
+                            f"✗ Version '{version}' failed to install ({success_count}/{total_count})"
+                        )
+                except SolcSelectError as e:
+                    if not silent:
+                        print(f"✗ Version '{version}' failed: {e} ({success_count}/{total_count})")
+
+        except KeyboardInterrupt:
+            if not silent:
+                print(f"\nCancelling installation... ({success_count}/{total_count} completed)")
+
+            # Cancel all pending futures
+            for future in future_to_version:
+                future.cancel()
+
+            # Shutdown executor immediately without waiting for running tasks
+            executor.shutdown(wait=False)
+            raise
+
+        finally:
+            # Clean shutdown for normal completion
+            if not executor._shutdown:
+                executor.shutdown(wait=True)
+
+        if not silent:
+            if success_count == total_count:
+                print(f"All {total_count} versions installed successfully!")
+            else:
+                print(f"{success_count}/{total_count} versions installed successfully")
 
-        return success
+        return success_count == total_count

solc_select/services/solc_service.py

@@ -18,6 +18,7 @@
     VersionNotInstalledError,
 )
 from ..infrastructure.filesystem import FilesystemManager
+from ..infrastructure.http_client import create_http_session
 from ..models import Platform, SolcVersion
 from ..repositories import CompositeRepository
 from .artifact_manager import ArtifactManager
@@ -34,9 +35,10 @@ def __init__(self, platform: Optional[Platform] = None):
 
         self.platform = platform
         self.filesystem = FilesystemManager()
-        self.repository = CompositeRepository(platform)
+        self.session = create_http_session()
+        self.repository = CompositeRepository(platform, self.session)
         self.version_manager = VersionManager(self.repository, platform)
-        self.artifact_manager = ArtifactManager(self.repository, platform)
+        self.artifact_manager = ArtifactManager(self.repository, platform, self.session)
         self.platform_service = PlatformService(platform)
 
     def get_current_version(self) -> Tuple[Optional[SolcVersion], str]: