refactor: better error handler (#24422)

Signed-off-by: -LAN- <laipz8200@outlook.com>

api/libs/external_api.py

@@ -16,98 +16,124 @@ def http_status_message(code):
     return HTTP_STATUS_CODES.get(code, "")
 
 
-class ExternalApi(Api):
-    def handle_error(self, e):
-        """Error handler for the API transforms a raised exception into a Flask
-        response, with the appropriate HTTP status code and body.
+def register_external_error_handlers(api: Api) -> None:
+    """Register error handlers for the API using decorators.
 
-        :param e: the raised Exception object
-        :type e: Exception
+    :param api: The Flask-RestX Api instance
+    """
 
-        """
+    @api.errorhandler(HTTPException)
+    def handle_http_exception(e: HTTPException):
+        """Handle HTTP exceptions."""
         got_request_exception.send(current_app, exception=e)
 
+        if e.response is not None:
+            return e.get_response()
+
         headers = Headers()
-        if isinstance(e, HTTPException):
-            if e.response is not None:
-                resp = e.get_response()
-                return resp
+        status_code = e.code
+        default_data = {
+            "code": re.sub(r"(?<!^)(?=[A-Z])", "_", type(e).__name__).lower(),
+            "message": getattr(e, "description", http_status_message(status_code)),
+            "status": status_code,
+        }
 
-            status_code = e.code
-            default_data = {
-                "code": re.sub(r"(?<!^)(?=[A-Z])", "_", type(e).__name__).lower(),
-                "message": getattr(e, "description", http_status_message(status_code)),
-                "status": status_code,
-            }
+        if (
+            default_data["message"]
+            and default_data["message"] == "Failed to decode JSON object: Expecting value: line 1 column 1 (char 0)"
+        ):
+            default_data["message"] = "Invalid JSON payload received or JSON payload is empty."
 
-            if (
-                default_data["message"]
-                and default_data["message"] == "Failed to decode JSON object: Expecting value: line 1 column 1 (char 0)"
-            ):
-                default_data["message"] = "Invalid JSON payload received or JSON payload is empty."
+        headers = e.get_response().headers
 
-            headers = e.get_response().headers
-        elif isinstance(e, ValueError):
-            status_code = 400
-            default_data = {
-                "code": "invalid_param",
-                "message": str(e),
-                "status": status_code,
-            }
-        elif isinstance(e, AppInvokeQuotaExceededError):
-            status_code = 429
-            default_data = {
-                "code": "too_many_requests",
-                "message": str(e),
-                "status": status_code,
-            }
+        # Handle specific status codes
+        if status_code == 406 and api.default_mediatype is None:
+            supported_mediatypes = list(api.representations.keys())
+            fallback_mediatype = supported_mediatypes[0] if supported_mediatypes else "text/plain"
+            data = {"code": "not_acceptable", "message": default_data.get("message")}
+            resp = api.make_response(data, status_code, headers, fallback_mediatype=fallback_mediatype)
+        elif status_code == 400:
+            if isinstance(default_data.get("message"), dict):
+                param_key, param_value = list(default_data.get("message", {}).items())[0]
+                data = {"code": "invalid_param", "message": param_value, "params": param_key}
+            else:
+                data = default_data
+                if "code" not in data:
+                    data["code"] = "unknown"
+            resp = api.make_response(data, status_code, headers)
         else:
-            status_code = 500
-            default_data = {
-                "message": http_status_message(status_code),
-            }
+            data = default_data
+            if "code" not in data:
+                data["code"] = "unknown"
+            resp = api.make_response(data, status_code, headers)
 
-        # Werkzeug exceptions generate a content-length header which is added
-        # to the response in addition to the actual content-length header
-        # https://github.com/flask-restful/flask-restful/issues/534
+        if status_code == 401:
+            resp = api.unauthorized(resp)
+
+        # Remove duplicate Content-Length header
         remove_headers = ("Content-Length",)
-
         for header in remove_headers:
             headers.pop(header, None)
 
+        return resp
+
+    @api.errorhandler(ValueError)
+    def handle_value_error(e: ValueError):
+        """Handle ValueError exceptions."""
+        got_request_exception.send(current_app, exception=e)
+
+        status_code = 400
+        data = {
+            "code": "invalid_param",
+            "message": str(e),
+            "status": status_code,
+        }
+        return api.make_response(data, status_code)
+
+    @api.errorhandler(AppInvokeQuotaExceededError)
+    def handle_quota_exceeded(e: AppInvokeQuotaExceededError):
+        """Handle AppInvokeQuotaExceededError exceptions."""
+        got_request_exception.send(current_app, exception=e)
+
+        status_code = 429
+        data = {
+            "code": "too_many_requests",
+            "message": str(e),
+            "status": status_code,
+        }
+        return api.make_response(data, status_code)
+
+    @api.errorhandler(Exception)
+    def handle_general_exception(e: Exception):
+        """Handle general exceptions."""
+        got_request_exception.send(current_app, exception=e)
+
+        headers = Headers()
+        status_code = 500
+        default_data = {
+            "message": http_status_message(status_code),
+        }
+
         data = getattr(e, "data", default_data)
 
-        # record the exception in the logs when we have a server error of status code: 500
-        if status_code and status_code >= 500:
-            exc_info: Any = sys.exc_info()
-            if exc_info[1] is None:
-                exc_info = None
-            current_app.log_exception(exc_info)
+        # Log server errors
+        exc_info: Any = sys.exc_info()
+        if exc_info[1] is None:
+            exc_info = None
+        current_app.log_exception(exc_info)
 
-        if status_code == 406 and self.default_mediatype is None:
-            # if we are handling NotAcceptable (406), make sure that
-            # make_response uses a representation we support as the
-            # default mediatype (so that make_response doesn't throw
-            # another NotAcceptable error).
-            supported_mediatypes = list(self.representations.keys())  # only supported application/json
-            fallback_mediatype = supported_mediatypes[0] if supported_mediatypes else "text/plain"
-            data = {"code": "not_acceptable", "message": data.get("message")}
-            resp = self.make_response(data, status_code, headers, fallback_mediatype=fallback_mediatype)
-        elif status_code == 400:
-            if isinstance(data.get("message"), dict):
-                param_key, param_value = list(data.get("message", {}).items())[0]
-                data = {"code": "invalid_param", "message": param_value, "params": param_key}
-            else:
-                if "code" not in data:
-                    data["code"] = "unknown"
+        if "code" not in data:
+            data["code"] = "unknown"
 
-            resp = self.make_response(data, status_code, headers)
-        else:
-            if "code" not in data:
-                data["code"] = "unknown"
+        # Remove duplicate Content-Length header
+        remove_headers = ("Content-Length",)
+        for header in remove_headers:
+            headers.pop(header, None)
 
-            resp = self.make_response(data, status_code, headers)
+        return api.make_response(data, status_code, headers)
 
-        if status_code == 401:
-            resp = self.unauthorized(resp)
-        return resp
+
+class ExternalApi(Api):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        register_external_error_handlers(self)