Stanislav Hejny
342 lines
16 KiB
Python
342 lines
16 KiB
Python
"""
|
|
The layer that interfaces with the CleverThis service that this Adapter is integrating with.
|
|
Methods here will invoke the actual CleverThis Service code, which are passed as Callable object.
|
|
"""
|
|
|
|
import json
|
|
import logging
|
|
import re
|
|
import sys
|
|
import traceback
|
|
from re import Pattern
|
|
from typing import Dict, List, Tuple, Callable, Coroutine, AnyStr, Any
|
|
from urllib.parse import parse_qs, urlparse
|
|
from xml.etree import ElementTree
|
|
|
|
from aiohttp import ClientSession, ClientResponse
|
|
from fastapi import HTTPException
|
|
|
|
from amqp.adapter import pydantic_serializer
|
|
from amqp.adapter.data_response_factory import DataResponseFactory
|
|
from amqp.config.amq_configuration import AMQConfiguration
|
|
from amqp.model.model import DataMessage, DataResponse
|
|
from amqp.service.multipart_parser import CleverMultiPartParser
|
|
|
|
|
|
def parse_request_body(message: DataMessage):
|
|
"""
|
|
Parses the HTTP POST request body based on the MIME type.
|
|
|
|
Args:
|
|
message (DataMessage): Contains raw request and MIME headers.
|
|
|
|
Returns:
|
|
dict: Parsed data as a dictionary.
|
|
"""
|
|
_content_type = message.headers.get('Content-Type', '')
|
|
if not _content_type:
|
|
raise ValueError("Content-Type header is required")
|
|
content_type = _content_type[0]
|
|
# Parse JSON
|
|
if content_type == "application/json":
|
|
try:
|
|
return json.loads(message.body())
|
|
except json.JSONDecodeError as e:
|
|
tb = traceback.extract_tb(sys.exc_info()[2])[-1]
|
|
logging.error(f" [E] Error in {tb.filename}, line {tb.lineno}, function '{tb.name}': {e}")
|
|
raise ValueError(f"Invalid JSON: {e}")
|
|
|
|
# Parse URL-encoded form data
|
|
elif content_type == "application/x-www-form-urlencoded":
|
|
try:
|
|
return {k: v[0] if len(v) == 1 else v for k, v in parse_qs(message.body()).items()}
|
|
except Exception as e:
|
|
tb = traceback.extract_tb(sys.exc_info()[2])[-1]
|
|
logging.error(f" [E] Error in {tb.filename}, line {tb.lineno}, function '{tb.name}': {e}")
|
|
raise ValueError(f"Invalid URL-encoded form data: {e}")
|
|
|
|
# Parse multipart/form-data
|
|
elif content_type.startswith("multipart/form-data"):
|
|
try:
|
|
parser: CleverMultiPartParser = CleverMultiPartParser(message)
|
|
return parser.form_data
|
|
except Exception as e:
|
|
tb = traceback.extract_tb(sys.exc_info()[2])[-1]
|
|
logging.error(f" [E] Error in {tb.filename}, line {tb.lineno}, function '{tb.name}': {e}")
|
|
raise ValueError(f"Invalid multipart/form-data: {e}")
|
|
|
|
# Parse plain text
|
|
elif content_type == "text/plain":
|
|
return {"text": message.body()}
|
|
|
|
# Parse XML
|
|
elif content_type == "application/xml":
|
|
try:
|
|
root = ElementTree.fromstring(message.body())
|
|
return {elem.tag: elem.text for elem in root}
|
|
except ElementTree.ParseError as e:
|
|
raise ValueError(f"Invalid XML: {e}")
|
|
|
|
else:
|
|
raise ValueError(f"Unsupported Content-Type: {content_type}")
|
|
|
|
|
|
async def call_cleverthis_post_put_api(
|
|
message: DataMessage,
|
|
args: Any,
|
|
api_method: Callable[[Any, Any], Coroutine],
|
|
success_code: int
|
|
) -> DataResponse:
|
|
"""
|
|
Handles POST and PUT requests, which typically contain possibly complex payload data, passed as a dictionary.
|
|
Invokes the provided API method with the given arguments and authenticated user,
|
|
and returns the response as DataResponse.
|
|
:param message: DataMessage containing the details of the call and the payload
|
|
:param args: map of the arguments to pass to the API method
|
|
:param api_method: Callable - the method to invoke. Last parameter is the authenticated user
|
|
:param success_code: HTTP code to be returned when operation suceeds
|
|
:return: DataResponse class
|
|
"""
|
|
try:
|
|
result: str = await api_method(**args)
|
|
return DataResponseFactory.of(
|
|
message.id, success_code, message.headers.get("Content-Type", "application/json"),
|
|
result.encode('utf-8'), message.trace_info
|
|
)
|
|
except HTTPException as http_error:
|
|
tb = traceback.extract_tb(sys.exc_info()[2])[-1]
|
|
logging.error(f" [E] Error in {tb.filename}, line {tb.lineno}, function '{tb.name}': {http_error}")
|
|
return DataResponseFactory.of(message.id, http_error.status_code, "text/plain",
|
|
str(http_error.detail).encode('utf-8'), message.trace_info)
|
|
except Exception as error:
|
|
tb = traceback.extract_tb(sys.exc_info()[2])[-1]
|
|
logging.error(f" [E] Error in {tb.filename}, line {tb.lineno}, function '{tb.name}': {error}")
|
|
return DataResponseFactory.of(message.id, 500, "text/plain", str(error).encode('utf-8'), message.trace_info)
|
|
|
|
|
|
def parse_get_url(url: str) -> Tuple[str, Dict[str, str]]:
|
|
"""
|
|
Parses an HTTP GET URL and returns (context_path, query_params_dict)
|
|
|
|
Args:
|
|
url: The URL string to parse (e.g., "http://example.com/path?foo=1&bar=2&foo=3")
|
|
|
|
Returns:
|
|
tuple: (context_path, query_params_dict)
|
|
- context_path: The path part of the URL (e.g., "/path")
|
|
- query_params_dict: Query parameters where values are str for single value or list of str for multivalue
|
|
"""
|
|
parsed = urlparse(url)
|
|
query_params = parse_qs(parsed.query)
|
|
# Convert values from lists to single values when there's only one value
|
|
simplified_params = {k: v[0] if len(v) == 1 else v for k, v in query_params.items()}
|
|
return parsed.path, simplified_params
|
|
|
|
async def call_cleverthis_get_api(
|
|
message: DataMessage,
|
|
pattern_or_data: Pattern| str | dict,
|
|
api_method: Callable[[Tuple[AnyStr | Any, ...], Any], Coroutine],
|
|
authenticated_user: Any
|
|
) -> DataResponse:
|
|
"""
|
|
Handles GET requests, which do not contain a body, but may have path variables and extra values
|
|
in the query string.
|
|
invokes provided Callable that is expected to be a GET API method, and returns the response as DataResponse
|
|
:param message: DataMessage containing the details of the call
|
|
:param pattern_or_data: If there are path variables, use this pattern to extract them
|
|
:param api_method: Callable - the method to invoke.
|
|
:param authenticated_user: Authenticated user. The actual class depends on the service
|
|
:return:
|
|
"""
|
|
try:
|
|
args = None
|
|
if isinstance(pattern_or_data, dict):
|
|
args = pattern_or_data
|
|
elif isinstance(pattern_or_data, Pattern):
|
|
path, args = pydantic_serializer.parse_url_query(message.path)
|
|
match = pattern_or_data.match(path)
|
|
if match:
|
|
args.update(match.groupdict())
|
|
else:
|
|
_msg = f"Unexpected URL: {message.path}, expected pattern: {pattern_or_data}"
|
|
return DataResponseFactory.of(message.id, 404, "text/plain", _msg.encode('utf-8'), message.trace_info)
|
|
else:
|
|
path, args = pydantic_serializer.parse_url_query(message.path)
|
|
match = re.search(pattern_or_data, path)
|
|
if match:
|
|
args.update(match.groupdict())
|
|
else:
|
|
_msg = f"Unexpected URL: {message.path}, expected pattern: {pattern_or_data}"
|
|
return DataResponseFactory.of(message.id, 404, "text/plain", _msg.encode('utf-8'), message.trace_info)
|
|
crt: Coroutine = api_method(args, authenticated_user)
|
|
result: str = await crt
|
|
return DataResponseFactory.of(message.id, 200, "text/plain", result.encode('utf-8'), message.trace_info)
|
|
|
|
except HTTPException as http_error:
|
|
tb = traceback.extract_tb(sys.exc_info()[2])[-1]
|
|
logging.error(f" [E] Error in {tb.filename}, line {tb.lineno}, function '{tb.name}': {http_error}")
|
|
return DataResponseFactory.of(message.id, http_error.status_code, "text/plain",
|
|
str(http_error.detail).encode('utf-8'), message.trace_info)
|
|
except Exception as error:
|
|
tb = traceback.extract_tb(sys.exc_info()[2])[-1]
|
|
logging.error(f" [E] Error in {tb.filename}, line {tb.lineno}, function '{tb.name}': {error}")
|
|
return DataResponseFactory.of(message.id, 500, "text/plain", str(error).encode('utf-8'), message.trace_info)
|
|
|
|
|
|
# ============= CleverThisServiceAdapter =============
|
|
class CleverThisServiceAdapter:
|
|
"""
|
|
A base class for CleverThis service adapter that handles the incoming AMQP messages and routes them to the
|
|
appropriate CleverThisService API endpoint.
|
|
IMPORTANT: This class is not intended to be used directly. It should be subclassed for each CleverThis service
|
|
and override the methods to handle the specific API calls.
|
|
"""
|
|
def __init__(self, amq_configuration: AMQConfiguration, session: ClientSession = None):
|
|
self.amq_configuration = amq_configuration
|
|
self.session = session
|
|
self.service_host = self.amq_configuration.dispatch.service_host
|
|
self.service_port = self.amq_configuration.dispatch.service_port
|
|
self.require_authenticated_user = self.amq_configuration.amq_adapter.require_authenticated_user
|
|
|
|
def get_content_type(self, message_headers: Dict[str, List[str]]) -> str:
|
|
"""
|
|
Pull the value of the Content-Type header from the message headers.
|
|
:param message_headers: The headers of the message.
|
|
return: The content type of the message.
|
|
"""
|
|
for header, values in message_headers.items():
|
|
if header.lower() == 'content-type':
|
|
return values[0].split(';')[0]
|
|
return 'application/json'
|
|
|
|
async def get_current_user(self, token: str):
|
|
"""
|
|
To Be Overriden in subclass for given CleverThis Service, to return the current user based on the token,
|
|
in format appropriate for the service.
|
|
:param token: The token to be used for authentication.
|
|
:return: A user object or None if the user is not authenticated.
|
|
"""
|
|
return None
|
|
|
|
async def on_message(self, message) -> DataResponse:
|
|
"""
|
|
Called when a message is received from the AMQP.
|
|
:param message:
|
|
:return: AMQP response class with operation status code and optional error details.
|
|
"""
|
|
_auth_user: Any | None = None
|
|
amq_response: DataResponse | None = None
|
|
|
|
if self.require_authenticated_user:
|
|
_auth: str = message.headers.get('Authorization', '')
|
|
if 'Bearer' in _auth:
|
|
try:
|
|
token = _auth.split(' ')[1]
|
|
_auth_user = await self.get_current_user(token)
|
|
except Exception as error:
|
|
logging.error(f"Error getting user: {error}")
|
|
|
|
if _auth_user or not self.require_authenticated_user:
|
|
method = message.method.lower()
|
|
if method == 'get':
|
|
amq_response = await self.get(message, _auth_user)
|
|
elif method == 'put':
|
|
amq_response = await self.put(message, _auth_user)
|
|
elif method == 'post':
|
|
amq_response = await self.post(message, _auth_user)
|
|
elif method == 'head':
|
|
amq_response = await self.head(message, _auth_user)
|
|
elif method == 'delete':
|
|
amq_response = await self.delete(message, _auth_user)
|
|
else:
|
|
raise ValueError(f"Unexpected HTTP method: {message.method}")
|
|
else:
|
|
amq_response = DataResponseFactory.of(message.id, 401, "text/plain", b"Unauthorized", message.trace_info)
|
|
|
|
return amq_response
|
|
|
|
# ==================================================================================================
|
|
# ===================== C l e v e r T h i s A P I m e t h o d s ============================
|
|
# ==================================================================================================
|
|
|
|
async def get(self, message: DataMessage, auth_user: Any) -> DataResponse:
|
|
"""
|
|
Handles the GET requests for the CleverThis API. to be overriden in subclass. This is a base implementation.
|
|
It will attempt to call the REST endpoint directly using HTTP protocol.
|
|
:param message: message from the AMQP that contains the GET request
|
|
:param auth_user: user authenticated by the API Gateway, as UserSchem
|
|
:return: DataResponse to be sent back to the API Gateway via AMQP
|
|
"""
|
|
|
|
# unmatched path - try to invoke the service directly on this path
|
|
url = f"http://{self.service_host}:{self.service_port}{message.path}"
|
|
headers = {**message.headers, **message.trace_info}
|
|
logging.info(f" [*] SEND HEADERS out: {', '.join(f'{k}={v}' for k, v in headers.items())}, REQ={url}")
|
|
if self.session:
|
|
_http_resp: ClientResponse = await self.session.get(url, headers=headers)
|
|
return DataResponseFactory.of(message.id, _http_resp.status, _http_resp.content_type,
|
|
await _http_resp.read(),
|
|
message.trace_info)
|
|
return DataResponseFactory.of(message.id, 404, "text/plain",
|
|
str("Destination location does not exists").encode('utf-8'), message.trace_info)
|
|
|
|
async def put(self, message: DataMessage, auth_user: Any) -> DataResponse:
|
|
"""
|
|
Handles the PUT requests for the CleverThis API. to be overriden in subclass. This is a base implementation.
|
|
It will attempt to call the REST endpoint directly using HTTP protocol.
|
|
:param message: message from the AMQP that contains the PUT request
|
|
:param auth_user: user authenticated by the API Gateway, as UserSchem
|
|
:return: DataResponse to be sent back to the API Gateway via AMQP
|
|
"""
|
|
return await self.handle_possible_form(
|
|
message,
|
|
self.session.put(
|
|
f"http://{self.service_host}:{self.service_port}{message.path}",
|
|
data=message.body,
|
|
headers={**message.headers, **message.trace_info},
|
|
),
|
|
auth_user
|
|
)
|
|
|
|
async def post(self, message: DataMessage, auth_user: Any) -> DataResponse:
|
|
"""
|
|
Handles the POST requests for the CleverThis API. to be overriden in subclass. This is a base implementation.
|
|
It will attempt to call the REST endpoint directly using HTTP protocol.
|
|
:param message: message from the AMQP that contains the POST request, including body and headers
|
|
:param auth_user: user authenticated by the API Gateway, as UserSchem
|
|
:return: DataResponse to be sent back to the API Gateway via AMQP
|
|
"""
|
|
return await self.handle_possible_form(
|
|
message,
|
|
self.session.post(
|
|
f"http://{self.service_host}:{self.service_port}{message.path}",
|
|
data=message.body,
|
|
headers={**message.headers, **message.trace_info},
|
|
),
|
|
auth_user
|
|
)
|
|
|
|
async def handle_possible_form(self, message: DataMessage, request_coroutine, auth_user: Any) -> DataResponse:
|
|
args = parse_request_body(message)
|
|
return await request_coroutine
|
|
|
|
async def head(self, message: DataMessage, auth_user: Any) -> DataResponse:
|
|
"""
|
|
Handles the HEAD requests for the CleverThis API. to be overriden in subclass. This is a base implementation.
|
|
It will attempt to call the REST endpoint directly using HTTP protocol.
|
|
:param message: message from the AMQP that contains the POST request, including body and headers
|
|
:param auth_user: user authenticated by the API Gateway, as UserSchem
|
|
:return: DataResponse to be sent back to the API Gateway via AMQP
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
async def delete(self, message: DataMessage, auth_user: Any) -> DataResponse:
|
|
"""
|
|
Handles the DELETE requests for the CleverThis API. to be overriden in subclass. This is a base implementation.
|
|
It will attempt to call the REST endpoint directly using HTTP protocol.
|
|
:param message: message from the AMQP that contains the POST request, including body and headers
|
|
:param auth_user: user authenticated by the API Gateway, as UserSchem
|
|
:return: DataResponse to be sent back to the API Gateway via AMQP
|
|
"""
|
|
raise NotImplementedError
|