115 lines
5.7 KiB
Python
115 lines
5.7 KiB
Python
import logging
|
|
from typing import Dict
|
|
from json import JSONDecodeError
|
|
|
|
import requests
|
|
from urllib3 import disable_warnings
|
|
|
|
from pyzipline.errors import KwargConflict, HTTPFailure, PyZiplineError
|
|
from pyzipline.models import Result
|
|
|
|
class RestAdapter:
|
|
def __init__(self, hostname: str, token: str = '', ssl: bool = True, enforced_signing: bool = True, logger: logging.Logger = None):
|
|
"""Constructor for RestAdapter
|
|
|
|
Args:
|
|
hostname (str): The hostname of your Zipline instance, WITHOUT https or http.
|
|
token (str = None): String used for authentication when making requests.
|
|
ssl (bool = True): Normally set to True, but if your Zipline instance doesn't use SSL/TLS, set this to False.
|
|
enforced_signing (bool = True): Normally set to True, but if having SSL/TLS cert validation issues, can turn off with False.
|
|
logger (logging.Logger = None) If your app has a logger, pass it in here.
|
|
|
|
Raises:
|
|
ValueError: Raised when the keyword arguments passed to the class constructor conflict.
|
|
"""
|
|
self._url = f"http{'s' if ssl else ''}://{hostname}/api/"
|
|
self._token = token
|
|
self._ssl = ssl
|
|
self._enforced_signing = enforced_signing
|
|
self._logger = logger or logging.getLogger(__name__)
|
|
|
|
if ssl is False and enforced_signing is True:
|
|
raise ValueError("Cannot enforce signing without SSL")
|
|
|
|
if not ssl and not enforced_signing:
|
|
disable_warnings()
|
|
|
|
def _do(self, http_method: str, endpoint: str, params: Dict = None, data: Dict = None) -> Result:
|
|
"""Internal method to make a request to the Zipline server. You shouldn't use this directly.
|
|
|
|
Args:
|
|
http_method (str): The HTTP method to use (GET, POST, DELETE)
|
|
endpoint (str): The endpoint to make the request to.
|
|
params (Dict = None): Python dictionary of query parameters to send with the request.
|
|
data (Dict = None): Python dictionary of data to send with the request.
|
|
|
|
Returns:
|
|
Result: A Result object containing the status code, message, and data from the request.
|
|
|
|
Raises:
|
|
HTTPError: Raised when an HTTP request fails.
|
|
PyZiplineError: Raised when an error occurs in the PyZipline library.
|
|
"""
|
|
full_url = self._url + endpoint
|
|
headers = {'Authorization': self._token}
|
|
|
|
log_line_pre = f"method={http_method}, url={full_url}, params={params}"
|
|
log_line_post = ', '.join((log_line_pre, "success={}, status_code={}, message={}"))
|
|
|
|
try: # Log HTTP params and perform an HTTP request, catching and re-raising any exceptions
|
|
self._logger.debug(msg=log_line_pre)
|
|
# will eventually refactor this to use asyncio/aiohttp instead for async operation
|
|
response = requests.request(method=http_method, url=full_url, verify=self._enforced_signing, params=params, headers=headers, json=data)
|
|
except requests.exceptions.RequestException as e:
|
|
self._logger.error(msg=(str(e)))
|
|
raise HTTPFailure("Could not connect to Zipline server") from e
|
|
|
|
try: # Deserialize JSON output to Python object, or return failed Result on exception
|
|
data_out = response.json()
|
|
except (ValueError, JSONDecodeError) as e:
|
|
self._logger.error(msg=log_line_post.format(False, None, e))
|
|
raise PyZiplineError("Could not decode response from Zipline server") from e
|
|
|
|
# If status_code in 200-299 range, return success Result with data, otherwise return failed Result with message
|
|
is_success = 299 >= response.status_code >= 200
|
|
|
|
self._logger.debug(msg=log_line_post.format(is_success, response.status_code, response.reason))
|
|
return Result(success=is_success, status_code=response.status_code, message=response.reason, data=data_out)
|
|
|
|
def get(self, endpoint: str, params: Dict = None) -> Result:
|
|
"""Make a GET request to the Zipline server. You should almost never have to use this directly.
|
|
|
|
Args:
|
|
endpoint (str): The endpoint to make the request to.
|
|
params (Dict = None): Python dictionary of query parameters to send with the request.
|
|
|
|
Returns:
|
|
Result: A Result object containing the status code, message, and data from the request.
|
|
"""
|
|
return self._do(http_method='GET', endpoint=endpoint, params=params)
|
|
|
|
def post(self, endpoint: str, params: Dict = None, data: Dict = None) -> Result:
|
|
"""Make a POST request to the Zipline server. You should almost never have to use this directly.
|
|
|
|
Args:
|
|
endpoint (str): The endpoint to make the request to.
|
|
params (Dict = None): Python dictionary of query parameters to send with the request.
|
|
data (Dict = None): Python dictionary of data to send with the request.
|
|
|
|
Returns:
|
|
Result: A Result object containing the status code, message, and data from the request.
|
|
"""
|
|
return self._do(http_method='POST', endpoint=endpoint, params=params, data=data)
|
|
|
|
def delete(self, endpoint: str, params: Dict = None, data: Dict = None) -> Result:
|
|
"""Make a DELETE request to the Zipline server. You should almost never have to use this directly.
|
|
|
|
Args:
|
|
endpoint (str): The endpoint to make the request to.
|
|
params (Dict = None): Python dictionary of query parameters to send with the request.
|
|
data (Dict = None): Python dictionary of data to send with the request.
|
|
|
|
Returns:
|
|
Result: A Result object containing the status code, message, and data from the request.
|
|
"""
|
|
return self._do(http_method='DELETE', endpoint=endpoint, params=params, data=data)
|