HTTP errors
Description
HTTP errors are objects with specific logic that can return a web server response with a predefined HTTP code.
Errors are raised using the raise statement.
from rapidy import Rapidy
from rapidy.http import get, HTTPBadRequest
@get('/')
async def handler() -> None:
raise HTTPBadRequest() # 400
app = Rapidy(http_route_handlers=[handler])
HTTP errors can be raised either by the developer or by the Rapidy web server itself if a client or server makes a mistake.
All errors are located in the rapidy.web_exceptions module, but they can also be imported from rapidy.http.
Types of HTTP errors
Rapidy supports four types of HTTP errors:
- 2xx — successful responses (base class —
HTTPSuccessful) - 3xx — redirections (base class —
HTTPRedirection) - 4xx — client errors (base class —
HTTPClientError) - 5xx — server errors (base class —
HTTPServerError)
Base classes can be used to handle all child errors.
More details about HTTP errors can be found in the aiohttp documentation here.
Raising HTTP errors
Raising an HTTP error by the developer
A developer can manually raise an error if request processing follows an unsuccessful scenario.
from rapidy import Rapidy
from rapidy.http import get, HTTPBadRequest
@get('/')
async def handler() -> None:
raise HTTPBadRequest() # 400
app = Rapidy(http_route_handlers=[handler])
Raising an HTTP error by the web server
The web server will automatically raise an error if a request cannot be processed.
Not Found — 404
Method Not Allowed — 405
Validation Error
If a web request fails validation, the client will receive a response in application/json format with an error description.
from pydantic import BaseModel, Field
from rapidy import Rapidy
from rapidy.http import post, Body
class BodyRequestSchema(BaseModel):
data: str = Field(min_length=3, max_length=20)
@post('/')
async def handler(
body: BodyRequestSchema = Body(),
) -> dict[str, str]:
return {'hello': 'rapidy'}
rapidy = Rapidy(http_route_handlers=[handler])
< HTTP/1.1 422 Unprocessable Entity ...
{
"errors": [
{
"loc": ["body", "data"],
"type": "string_too_short",
"msg": "String should have at least 3 characters",
"ctx": {"min_length": 3}
}
]
}
The HTTPValidationFailure error contains a list of errors in the validation_errors field.
To access these errors, you can catch HTTPValidationFailure:
HTTPValidationFailure inherits from HTTPUnprocessableEntity.
This means that both errors can be handled using HTTPUnprocessableEntity if you do not need to disclose detailed error information to the client.
Error Handling
Sometimes it is necessary to catch an error, for example, to modify the server response.
This can be done using middleware:
from logging import getLogger
from rapidy.http import (
middleware, Request, StreamResponse, HTTPValidationFailure, HTTPInternalServerError, HTTPException,
)
from rapidy.typedefs import CallNext
logger = getLogger(__name__)
@middleware
async def error_catch_middleware(
request: Request,
call_next: CallNext,
) -> StreamResponse:
try:
return await call_next(request)
except HTTPValidationFailure as validation_failure_error:
validation_errors = validation_failure_error.validation_errors
logger.debug('Ошибка валидации: `%s request: %s`', str(request.rel_url), validation_errors)
raise validation_failure_error
except HTTPInternalServerError as server_error:
logger.info('Внутренняя ошибка сервера: %s', server_error)
raise server_error
except HTTPException as unhandled_http_error:
raise unhandled_http_error
except Exception as unhandled_error:
logger.exception('Ошибка при обработке `%s`: %s', str(request.rel_url), unhandled_error)
raise HTTPInternalServerError
Example of handling all errors with a unified response
from http import HTTPStatus
from logging import getLogger
from typing import Any
from pydantic import BaseModel
from rapidy import Rapidy, run_app
from rapidy.http import (
get,
middleware,
Request,
Response,
StreamResponse,
HTTPValidationFailure,
HTTPClientError,
HTTPInternalServerError,
HTTPException,
)
from rapidy.typedefs import CallNext, ValidationErrorList
logger = getLogger(__name__)
class ServerResponse(BaseModel):
message: str = 'Success'
result: Any | None = None
errors: ValidationErrorList | None = None
@middleware
async def error_catch_middleware(
request: Request,
call_next: CallNext,
response: Response,
) -> StreamResponse | ServerResponse:
try:
return await call_next(request)
except HTTPValidationFailure as validation_failure_error:
validation_errors = validation_failure_error.validation_errors
logger.debug('Validation error while processing: `%s request: %s', str(request.rel_url), validation_errors)
response.set_status(validation_failure_error.status)
return ServerResponse(message='Validation error', errors=validation_errors)
except HTTPClientError as client_error: # all other `4xx' errors
logger.info('Client error while processing: %s request: %s', str(request.rel_url), client_error)
response.set_status(client_error.status)
return ServerResponse(message=client_error.reason)
except HTTPInternalServerError as server_error:
logger.info('Internal error - server raise HTTPInternalServerError: %s', server_error)
response.set_status(server_error.status)
return ServerResponse(message=server_error.reason)
except HTTPException as unhandled_http_error: # all other unhandled http-errors
raise unhandled_http_error
except Exception as unhandled_error:
logger.exception('Internal error while processing `%s` error: %s', str(request.rel_url), unhandled_error)
response.set_status(HTTPStatus.INTERNAL_SERVER_ERROR)
return ServerResponse(message='Internal server error')
@get('/')
async def handler() -> ServerResponse:
return ServerResponse(result={'hello': 'rapidy'})
app = Rapidy(middlewares=[error_catch_middleware], http_route_handlers=[handler])
if __name__ == '__main__':
run_app(app)