Complete directives implementation, refactor exceptions, deprecate VRFs, bump minimum Python version

hyperglass/exceptions/public.py

@@ -0,0 +1,165 @@
+"""User-facing/Public exceptions."""
+
+# Standard Library
+from typing import Any, Dict, Optional, ForwardRef
+
+# Project
+from hyperglass.configuration import params
+
+# Local
+from ._common import PublicHyperglassError
+
+Query = ForwardRef("Query")
+Device = ForwardRef("Device")
+
+
+class ScrapeError(
+    PublicHyperglassError, template=params.messages.connection_error, level="danger",
+):
+    """Raised when an SSH driver error occurs."""
+
+    def __init__(self, error: BaseException, *, device: Device):
+        """Initialize parent error."""
+        super().__init__(error=str(error), device=device.name, proxy=device.proxy)
+
+
+class AuthError(
+    PublicHyperglassError, template=params.messages.authentication_error, level="danger"
+):
+    """Raised when authentication to a device fails."""
+
+    def __init__(self, error: BaseException, *, device: Device):
+        """Initialize parent error."""
+        super().__init__(error=str(error), device=device.name, proxy=device.proxy)
+
+
+class RestError(
+    PublicHyperglassError, template=params.messages.connection_error, level="danger"
+):
+    """Raised upon a rest API client error."""
+
+    def __init__(self, error: BaseException, *, device: Device):
+        """Initialize parent error."""
+        super().__init__(error=str(error), device=device.name)
+
+
+class DeviceTimeout(
+    PublicHyperglassError, template=params.messages.request_timeout, level="danger"
+):
+    """Raised when the connection to a device times out."""
+
+    def __init__(self, error: BaseException, *, device: Device):
+        """Initialize parent error."""
+        super().__init__(error=str(error), device=device.name, proxy=device.proxy)
+
+
+class InvalidQuery(PublicHyperglassError, template=params.messages.invalid_query):
+    """Raised when input validation fails."""
+
+    def __init__(
+        self, error: Optional[str] = None, *, query: "Query", **kwargs: Dict[str, Any]
+    ) -> None:
+        """Initialize parent error."""
+
+        kwargs = {
+            "query_type": query.query_type,
+            "target": query.query_target,
+            **kwargs,
+        }
+        if error is not None:
+            self.handle_error(error)
+            kwargs["error"] = str(error)
+
+        super().__init__(**kwargs)
+
+
+class NotFound(PublicHyperglassError, template=params.messages.not_found):
+    """Raised when an object is not found."""
+
+    def __init__(self, type: str, name: str, **kwargs: Dict[str, str]) -> None:
+        """Initialize parent error."""
+        super().__init__(type=type, name=name, **kwargs)
+
+
+class QueryLocationNotFound(NotFound):
+    """Raised when a query location is not found."""
+
+    def __init__(self, location: Any, **kwargs: Dict[str, Any]) -> None:
+        """Initialize a NotFound error for a query location."""
+        super().__init__(
+            type=params.web.text.query_location, name=str(location), **kwargs
+        )
+
+
+class QueryTypeNotFound(NotFound):
+    """Raised when a query type is not found."""
+
+    def __init__(self, query_type: Any, **kwargs: Dict[str, Any]) -> None:
+        """Initialize a NotFound error for a query type."""
+        super().__init__(
+            type=params.web.text.query_type, name=str(query_type), **kwargs
+        )
+
+
+class QueryGroupNotFound(NotFound):
+    """Raised when a query group is not found."""
+
+    def __init__(self, group: Any, **kwargs: Dict[str, Any]) -> None:
+        """Initialize a NotFound error for a query group."""
+        super().__init__(type=params.web.text.query_group, name=str(group), **kwargs)
+
+
+class InputInvalid(PublicHyperglassError, template=params.messages.invalid_input):
+    """Raised when input validation fails."""
+
+    def __init__(
+        self, error: Optional[Any] = None, *, target: str, **kwargs: Dict[str, Any]
+    ) -> None:
+        """Initialize parent error."""
+
+        kwargs = {"target": target, **kwargs}
+        if error is not None:
+            self.handle_error(error)
+            kwargs["error"] = str(error)
+
+        super().__init__(**kwargs)
+
+
+class InputNotAllowed(PublicHyperglassError, template=params.messages.acl_not_allowed):
+    """Raised when input validation fails due to a configured check."""
+
+    def __init__(
+        self, error: Optional[str] = None, *, query: Query, **kwargs: Dict[str, Any]
+    ) -> None:
+        """Initialize parent error."""
+
+        kwargs = {
+            "query_type": query.query_type,
+            "target": query.query_target,
+            **kwargs,
+        }
+        if error is not None:
+            self.handle_error(error)
+            kwargs["error"] = str(error)
+
+        super().__init__(**kwargs)
+
+
+class ResponseEmpty(PublicHyperglassError, template=params.messages.no_output):
+    """Raised when hyperglass can connect to the device but the response is empty."""
+
+    def __init__(
+        self, error: Optional[str] = None, *, query: Query, **kwargs: Dict[str, Any]
+    ) -> None:
+        """Initialize parent error."""
+
+        kwargs = {
+            "query_type": query.query_type,
+            "target": query.query_target,
+            **kwargs,
+        }
+        if error is not None:
+            self.handle_error(error)
+            kwargs["error"] = str(error)
+
+        super().__init__(**kwargs)