Better Provider Exceptions

Author: Behemyth

cppython/plugins/conan/plugin.py

@@ -20,7 +20,7 @@
 from cppython.plugins.conan.builder import Builder
 from cppython.plugins.conan.resolution import resolve_conan_data, resolve_conan_dependency
 from cppython.plugins.conan.schema import ConanData
-from cppython.utility.exception import NotSupportedError
+from cppython.utility.exception import NotSupportedError, ProviderConfigurationError, ProviderInstallationError
 from cppython.utility.utility import TypeName
 
 
@@ -76,44 +76,49 @@ def _install_dependencies(self, *, update: bool = False) -> None:
             update: If True, check remotes for newer versions/revisions and install those.
                    If False, use cached versions when available.
         """
-        resolved_dependencies = [resolve_conan_dependency(req) for req in self.core_data.cppython_data.dependencies]
-
-        self.builder.generate_conanfile(self.core_data.project_data.project_root, resolved_dependencies)
-
-        self.core_data.cppython_data.build_path.mkdir(parents=True, exist_ok=True)
-
-        # Install/update dependencies using Conan API
-        project_root = self.core_data.project_data.project_root
-        conanfile_path = project_root / 'conanfile.py'
+        try:
+            resolved_dependencies = [resolve_conan_dependency(req) for req in self.core_data.cppython_data.dependencies]
+
+            self.builder.generate_conanfile(self.core_data.project_data.project_root, resolved_dependencies)
+
+            self.core_data.cppython_data.build_path.mkdir(parents=True, exist_ok=True)
+
+            # Install/update dependencies using Conan API
+            project_root = self.core_data.project_data.project_root
+            conanfile_path = project_root / 'conanfile.py'
+
+            if conanfile_path.exists():
+                # Initialize Conan API
+                conan_api = ConanAPI()
+
+                # Get default profiles
+                profile_host_path = conan_api.profiles.get_default_host()
+                profile_build_path = conan_api.profiles.get_default_build()
+                profile_host = conan_api.profiles.get_profile([profile_host_path])
+                profile_build = conan_api.profiles.get_profile([profile_build_path])
+
+                # Build dependency graph for the package
+                deps_graph = conan_api.graph.load_graph_consumer(
+                    path=str(conanfile_path),
+                    name=None,
+                    version=None,
+                    user=None,
+                    channel=None,
+                    profile_host=profile_host,
+                    profile_build=profile_build,
+                    lockfile=None,
+                    remotes=conan_api.remotes.list(),
+                    update=update,
+                    check_updates=update,
+                    is_build_require=False,
+                )
 
-        if conanfile_path.exists():
-            # Initialize Conan API
-            conan_api = ConanAPI()
-
-            # Get default profiles
-            profile_host_path = conan_api.profiles.get_default_host()
-            profile_build_path = conan_api.profiles.get_default_build()
-            profile_host = conan_api.profiles.get_profile([profile_host_path])
-            profile_build = conan_api.profiles.get_profile([profile_build_path])
-
-            # Build dependency graph for the package
-            deps_graph = conan_api.graph.load_graph_consumer(
-                path=str(conanfile_path),
-                name=None,
-                version=None,
-                user=None,
-                channel=None,
-                profile_host=profile_host,
-                profile_build=profile_build,
-                lockfile=None,
-                remotes=conan_api.remotes.list(),
-                update=update,
-                check_updates=update,
-                is_build_require=False,
-            )
-
-            # Install dependencies
-            conan_api.install.install_binaries(deps_graph=deps_graph, remotes=conan_api.remotes.list())
+                # Install dependencies
+                conan_api.install.install_binaries(deps_graph=deps_graph, remotes=conan_api.remotes.list())
+        except Exception as e:
+            operation = 'update' if update else 'install'
+            error_msg = str(e)
+            raise ProviderInstallationError('conan', f'Failed to {operation} dependencies: {error_msg}', e) from e
 
     def install(self) -> None:
         """Installs the provider"""
@@ -229,7 +234,7 @@ def publish(self) -> None:
                 # Get the first configured remote or raise an error
                 remotes = conan_api.remotes.list()
                 if not remotes:
-                    raise RuntimeError('No remotes configured for upload')
+                    raise ProviderConfigurationError('conan', 'No remotes configured for upload', 'remotes')
 
                 remote = remotes[0]  # Use first remote
 
@@ -244,4 +249,4 @@ def publish(self) -> None:
                     dry_run=False,
                 )
             else:
-                raise RuntimeError('No packages found to upload')
+                raise ProviderInstallationError('conan', 'No packages found to upload')

cppython/plugins/vcpkg/plugin.py

@@ -17,7 +17,7 @@
 from cppython.plugins.cmake.schema import CMakeSyncData
 from cppython.plugins.vcpkg.resolution import generate_manifest, resolve_vcpkg_data
 from cppython.plugins.vcpkg.schema import VcpkgData
-from cppython.utility.exception import NotSupportedError
+from cppython.utility.exception import NotSupportedError, ProviderInstallationError, ProviderToolingError
 from cppython.utility.utility import TypeName
 
 
@@ -92,10 +92,9 @@ def _update_provider(cls, path: Path) -> None:
                     capture_output=True,
                 )
         except subprocess.CalledProcessError as e:
-            logger.error(
-                'Unable to bootstrap the vcpkg repository: %s', e.stderr.decode() if e.stderr else str(e), exc_info=True
-            )
-            raise
+            error_msg = e.stderr.decode() if e.stderr else str(e)
+            logger.error('Unable to bootstrap the vcpkg repository: %s', error_msg, exc_info=True)
+            raise ProviderToolingError('vcpkg', 'bootstrap', error_msg, e) from e
 
     def sync_data(self, consumer: SyncConsumer) -> SyncData:
         """Gathers a data object for the given generator
@@ -167,8 +166,9 @@ async def download_tooling(cls, directory: Path) -> None:
                     capture_output=True,
                 )
             except subprocess.CalledProcessError as e:
-                logger.exception('Unable to update the vcpkg repository: %s', e.stderr.decode() if e.stderr else str(e))
-                raise
+                error_msg = e.stderr.decode() if e.stderr else str(e)
+                logger.error('Unable to update the vcpkg repository: %s', error_msg, exc_info=True)
+                raise ProviderToolingError('vcpkg', 'update', error_msg, e) from e
         else:
             try:
                 logger.debug("Cloning the vcpkg repository to '%s'", directory.absolute())
@@ -182,8 +182,9 @@ async def download_tooling(cls, directory: Path) -> None:
                 )
 
             except subprocess.CalledProcessError as e:
-                logger.exception('Unable to clone the vcpkg repository: %s', e.stderr.decode() if e.stderr else str(e))
-                raise
+                error_msg = e.stderr.decode() if e.stderr else str(e)
+                logger.error('Unable to clone the vcpkg repository: %s', error_msg, exc_info=True)
+                raise ProviderToolingError('vcpkg', 'clone', error_msg, e) from e
 
         cls._update_provider(directory)
 
@@ -210,8 +211,9 @@ def install(self) -> None:
                 capture_output=True,
             )
         except subprocess.CalledProcessError as e:
-            logger.exception('Unable to install project dependencies: %s', e.stderr.decode() if e.stderr else str(e))
-            raise
+            error_msg = e.stderr.decode() if e.stderr else str(e)
+            logger.error('Unable to install project dependencies: %s', error_msg, exc_info=True)
+            raise ProviderInstallationError('vcpkg', error_msg, e) from e
 
     def update(self) -> None:
         """Called when dependencies need to be updated and written to the lock file."""
@@ -237,8 +239,9 @@ def update(self) -> None:
                 capture_output=True,
             )
         except subprocess.CalledProcessError as e:
-            logger.exception('Unable to install project dependencies: %s', e.stderr.decode() if e.stderr else str(e))
-            raise
+            error_msg = e.stderr.decode() if e.stderr else str(e)
+            logger.error('Unable to update project dependencies: %s', error_msg, exc_info=True)
+            raise ProviderInstallationError('vcpkg', error_msg, e) from e
 
     def publish(self) -> None:
         """Called when the project needs to be published.

cppython/project.py

@@ -56,7 +56,7 @@ def install(self) -> None:
         """Installs project dependencies
 
         Raises:
-            Exception: Raised if failed
+            Exception: Provider-specific exceptions are propagated with full context
         """
         if not self._enabled:
             self.logger.info('Skipping install because the project is not enabled')
@@ -68,19 +68,15 @@ def install(self) -> None:
         self.logger.info('Installing project')
         self.logger.info('Installing %s provider', self._data.plugins.provider.name())
 
-        try:
-            self._data.plugins.provider.install()
-        except Exception as exception:
-            self.logger.error('Unexpected error during installation: %s', str(exception))
-            raise SystemExit('Error: An unexpected error occurred during installation.') from None
-
+        # Let provider handle its own exceptions for better error context
+        self._data.plugins.provider.install()
         self._data.sync()
 
     def update(self) -> None:
         """Updates project dependencies
 
         Raises:
-            Exception: Raised if failed
+            Exception: Provider-specific exception
         """
         if not self._enabled:
             self.logger.info('Skipping update because the project is not enabled')
@@ -92,18 +88,15 @@ def update(self) -> None:
         self.logger.info('Updating project')
         self.logger.info('Updating %s provider', self._data.plugins.provider.name())
 
-        try:
-            self._data.plugins.provider.update()
-        except Exception as exception:
-            self.logger.error('Unexpected error during update: %s', str(exception))
-            raise SystemExit('Error: An unexpected error occurred during update.') from None
-
+        # Let provider handle its own exceptions for better error context
+        self._data.plugins.provider.update()
         self._data.sync()
 
     def publish(self) -> None:
-        """Publishes the project"""
-        try:
-            self._data.plugins.provider.publish()
-        except Exception as exception:
-            self.logger.error('Unexpected error during publish: %s', str(exception))
-            raise SystemExit('Error: An unexpected error occurred during publish.') from None
+        """Publishes the project
+
+        Raises:
+            Exception: Provider-specific exception
+        """
+        # Let provider handle its own exceptions for better error context
+        self._data.plugins.provider.publish()

cppython/utility/exception.py

@@ -45,3 +45,155 @@ def error(self) -> str:
             str -- The underlying error
         """
         return self._error
+
+
+class ProviderInstallationError(Exception):
+    """Raised when provider installation fails"""
+
+    def __init__(self, provider_name: str, error: str, original_error: Exception | None = None) -> None:
+        """Initializes the error
+
+        Args:
+            provider_name: The name of the provider that failed
+            error: The error message
+            original_error: The original exception that caused this error
+        """
+        self._provider_name = provider_name
+        self._error = error
+        self._original_error = original_error
+
+        message = f"Provider '{provider_name}' installation failed: {error}"
+        super().__init__(message)
+
+    @property
+    def provider_name(self) -> str:
+        """Returns the provider name
+
+        Returns:
+            str -- The provider name
+        """
+        return self._provider_name
+
+    @property
+    def error(self) -> str:
+        """Returns the underlying error
+
+        Returns:
+            str -- The underlying error
+        """
+        return self._error
+
+    @property
+    def original_error(self) -> Exception | None:
+        """Returns the original exception
+
+        Returns:
+            Exception | None -- The original exception if available
+        """
+        return self._original_error
+
+
+class ProviderConfigurationError(Exception):
+    """Raised when provider configuration is invalid"""
+
+    def __init__(self, provider_name: str, error: str, configuration_key: str | None = None) -> None:
+        """Initializes the error
+
+        Args:
+            provider_name: The name of the provider with invalid configuration
+            error: The error message
+            configuration_key: The specific configuration key that caused the error
+        """
+        self._provider_name = provider_name
+        self._error = error
+        self._configuration_key = configuration_key
+
+        message = f"Provider '{provider_name}' configuration error"
+        if configuration_key:
+            message += f" in '{configuration_key}'"
+        message += f': {error}'
+        super().__init__(message)
+
+    @property
+    def provider_name(self) -> str:
+        """Returns the provider name
+
+        Returns:
+            str -- The provider name
+        """
+        return self._provider_name
+
+    @property
+    def error(self) -> str:
+        """Returns the underlying error
+
+        Returns:
+            str -- The underlying error
+        """
+        return self._error
+
+    @property
+    def configuration_key(self) -> str | None:
+        """Returns the configuration key
+
+        Returns:
+            str | None -- The configuration key if available
+        """
+        return self._configuration_key
+
+
+class ProviderToolingError(Exception):
+    """Raised when provider tooling operations fail"""
+
+    def __init__(self, provider_name: str, operation: str, error: str, original_error: Exception | None = None) -> None:
+        """Initializes the error
+
+        Args:
+            provider_name: The name of the provider that failed
+            operation: The operation that failed (e.g., 'download', 'bootstrap', 'install')
+            error: The error message
+            original_error: The original exception that caused this error
+        """
+        self._provider_name = provider_name
+        self._operation = operation
+        self._error = error
+        self._original_error = original_error
+
+        message = f"Provider '{provider_name}' {operation} failed: {error}"
+        super().__init__(message)
+
+    @property
+    def provider_name(self) -> str:
+        """Returns the provider name
+
+        Returns:
+            str -- The provider name
+        """
+        return self._provider_name
+
+    @property
+    def operation(self) -> str:
+        """Returns the operation that failed
+
+        Returns:
+            str -- The operation name
+        """
+        return self._operation
+
+    @property
+    def error(self) -> str:
+        """Returns the underlying error
+
+        Returns:
+            str -- The underlying error
+        """
+        return self._error
+
+    @property
+    def original_error(self) -> Exception | None:
+        """Returns the original exception
+
+        Returns:
+            Exception | None -- The original exception if available
+        """
+        return self._original_error