263 lines
9.8 KiB
Python
263 lines
9.8 KiB
Python
"""
|
|
http.py : Trovebox HTTP Access
|
|
"""
|
|
from __future__ import unicode_literals
|
|
import sys
|
|
import requests
|
|
import requests_oauthlib
|
|
import logging
|
|
try:
|
|
from urllib.parse import urlparse, urlunparse # Python3
|
|
except ImportError:
|
|
from urlparse import urlparse, urlunparse # Python2
|
|
|
|
from trovebox.objects.trovebox_object import TroveboxObject
|
|
from .errors import TroveboxError, Trovebox404Error, TroveboxDuplicateError
|
|
from .auth import Auth
|
|
|
|
if sys.version < '3':
|
|
TEXT_TYPE = unicode
|
|
else: # pragma: no cover
|
|
TEXT_TYPE = str
|
|
|
|
DUPLICATE_RESPONSE = {"code": 409,
|
|
"message": "This photo already exists"}
|
|
|
|
class Http(object):
|
|
"""
|
|
Base class to handle HTTP requests to a Trovebox server.
|
|
If no parameters are specified, auth config is loaded from the
|
|
default location (~/.config/trovebox/default).
|
|
The config_file parameter is used to specify an alternate config file.
|
|
If the host parameter is specified, no config file is loaded and
|
|
OAuth tokens (consumer*, token*) can optionally be specified.
|
|
"""
|
|
|
|
_CONFIG_DEFAULTS = {"api_version" : None,
|
|
"ssl_verify" : True,
|
|
}
|
|
|
|
def __init__(self, config_file=None, host=None,
|
|
consumer_key='', consumer_secret='',
|
|
token='', token_secret='', api_version=None):
|
|
|
|
self.config = dict(self._CONFIG_DEFAULTS)
|
|
|
|
if api_version is not None: # pragma: no cover
|
|
print("Deprecation Warning: api_version should be set by "
|
|
"calling the configure function")
|
|
self.config["api_version"] = api_version
|
|
|
|
self._logger = logging.getLogger("trovebox")
|
|
|
|
self.auth = Auth(config_file, host,
|
|
consumer_key, consumer_secret,
|
|
token, token_secret)
|
|
|
|
self.host = self.auth.host
|
|
|
|
# Remember the most recent HTTP request and response
|
|
self.last_url = None
|
|
self.last_params = None
|
|
self.last_response = None
|
|
|
|
def configure(self, **kwds):
|
|
"""
|
|
Update Trovebox HTTP client configuration.
|
|
|
|
:param api_version: Include a Trovebox API version in all requests.
|
|
This can be used to ensure that your application will continue
|
|
to work even if the Trovebox API is updated to a new revision.
|
|
[default: None]
|
|
:param ssl_verify: If true, HTTPS SSL certificates will always be
|
|
verified [default: True]
|
|
"""
|
|
for item in kwds:
|
|
self.config[item] = kwds[item]
|
|
|
|
def get(self, endpoint, process_response=True, **params):
|
|
"""
|
|
Performs an HTTP GET from the specified endpoint (API path),
|
|
passing parameters if given.
|
|
The api_version is prepended to the endpoint,
|
|
if it was specified when the Trovebox object was created.
|
|
|
|
Returns the decoded JSON dictionary, and raises exceptions if an
|
|
error code is received.
|
|
Returns the raw response if process_response=False
|
|
"""
|
|
params = self._process_params(params)
|
|
url = self._construct_url(endpoint)
|
|
|
|
if self.auth.consumer_key:
|
|
auth = requests_oauthlib.OAuth1(self.auth.consumer_key,
|
|
self.auth.consumer_secret,
|
|
self.auth.token,
|
|
self.auth.token_secret)
|
|
else:
|
|
auth = None
|
|
|
|
with requests.Session() as session:
|
|
session.verify = self.config["ssl_verify"]
|
|
response = session.get(url, params=params, auth=auth)
|
|
|
|
self._logger.info("============================")
|
|
self._logger.info("GET %s" % url)
|
|
self._logger.info("---")
|
|
self._logger.info(response.text[:1000])
|
|
if len(response.text) > 1000: # pragma: no cover
|
|
self._logger.info("[Response truncated to 1000 characters]")
|
|
|
|
self.last_url = url
|
|
self.last_params = params
|
|
self.last_response = response
|
|
|
|
if process_response:
|
|
return self._process_response(response)
|
|
else:
|
|
if 200 <= response.status_code < 300:
|
|
return response.text
|
|
else:
|
|
raise TroveboxError("HTTP Error %d: %s" %
|
|
(response.status_code, response.reason))
|
|
|
|
def post(self, endpoint, process_response=True, files=None, **params):
|
|
"""
|
|
Performs an HTTP POST to the specified endpoint (API path),
|
|
passing parameters if given.
|
|
The api_version is prepended to the endpoint,
|
|
if it was specified when the Trovebox object was created.
|
|
|
|
Returns the decoded JSON dictionary, and raises exceptions if an
|
|
error code is received.
|
|
Returns the raw response if process_response=False
|
|
"""
|
|
params = self._process_params(params)
|
|
url = self._construct_url(endpoint)
|
|
|
|
if not self.auth.consumer_key:
|
|
raise TroveboxError("Cannot issue POST without OAuth tokens")
|
|
|
|
auth = requests_oauthlib.OAuth1(self.auth.consumer_key,
|
|
self.auth.consumer_secret,
|
|
self.auth.token,
|
|
self.auth.token_secret)
|
|
with requests.Session() as session:
|
|
session.verify = self.config["ssl_verify"]
|
|
if files:
|
|
# Need to pass parameters as URL query, so they get OAuth signed
|
|
response = session.post(url, params=params,
|
|
files=files, auth=auth)
|
|
else:
|
|
# Passing parameters as URL query doesn't work
|
|
# if there are no files to send.
|
|
# Send them as form data instead.
|
|
response = session.post(url, data=params, auth=auth)
|
|
|
|
self._logger.info("============================")
|
|
self._logger.info("POST %s" % url)
|
|
self._logger.info("params: %s" % repr(params))
|
|
if files:
|
|
self._logger.info("files: %s" % repr(files))
|
|
self._logger.info("---")
|
|
self._logger.info(response.text[:1000])
|
|
if len(response.text) > 1000: # pragma: no cover
|
|
self._logger.info("[Response truncated to 1000 characters]")
|
|
|
|
self.last_url = url
|
|
self.last_params = params
|
|
self.last_response = response
|
|
|
|
if process_response:
|
|
return self._process_response(response)
|
|
else:
|
|
if 200 <= response.status_code < 300:
|
|
return response.text
|
|
else:
|
|
raise TroveboxError("HTTP Error %d: %s" %
|
|
(response.status_code, response.reason))
|
|
|
|
def _construct_url(self, endpoint):
|
|
"""Return the full URL to the specified endpoint"""
|
|
parsed_url = urlparse(self.host)
|
|
scheme = parsed_url[0]
|
|
host = parsed_url[1]
|
|
# Handle host without a scheme specified (eg. www.example.com)
|
|
if scheme == "":
|
|
scheme = "http"
|
|
host = self.host
|
|
|
|
if not endpoint.startswith("/"):
|
|
endpoint = "/" + endpoint
|
|
if self.config["api_version"] is not None:
|
|
endpoint = "/v%d%s" % (self.config["api_version"], endpoint)
|
|
return urlunparse((scheme, host, endpoint, '', '', ''))
|
|
|
|
def _process_params(self, params):
|
|
""" Converts Unicode/lists/booleans inside HTTP parameters """
|
|
processed_params = {}
|
|
for key, value in params.items():
|
|
processed_params[key] = self._process_param_value(value)
|
|
|
|
return processed_params
|
|
|
|
def _process_param_value(self, value):
|
|
"""
|
|
Returns a UTF-8 string representation of the parameter value,
|
|
recursing into lists.
|
|
"""
|
|
# Extract IDs from objects
|
|
if isinstance(value, TroveboxObject):
|
|
return str(value.id).encode('utf-8')
|
|
|
|
# Ensure strings are UTF-8 encoded
|
|
elif isinstance(value, TEXT_TYPE):
|
|
return value.encode("utf-8")
|
|
|
|
# Handle lists
|
|
elif isinstance(value, list):
|
|
# Make a copy of the list, to avoid overwriting the original
|
|
new_list = list(value)
|
|
# Process each item in the list
|
|
for i, item in enumerate(new_list):
|
|
new_list[i] = self._process_param_value(item)
|
|
# new_list elements are UTF-8 encoded strings - simply join up
|
|
return b','.join(new_list)
|
|
|
|
# Handle booleans
|
|
elif isinstance(value, bool):
|
|
return b"1" if value else b"0"
|
|
|
|
# Unknown - just do our best
|
|
else:
|
|
return str(value).encode("utf-8")
|
|
|
|
@staticmethod
|
|
def _process_response(response):
|
|
"""
|
|
Decodes the JSON response, returning a dict.
|
|
Raises an exception if an invalid response code is received.
|
|
"""
|
|
if response.status_code == 404:
|
|
raise Trovebox404Error("HTTP Error %d: %s" %
|
|
(response.status_code, response.reason))
|
|
try:
|
|
json_response = response.json()
|
|
code = json_response["code"]
|
|
message = json_response["message"]
|
|
except (ValueError, KeyError):
|
|
# Response wasn't Trovebox JSON - check the HTTP status code
|
|
if 200 <= response.status_code < 300:
|
|
# Status code was valid, so just reraise the exception
|
|
raise
|
|
else:
|
|
raise TroveboxError("HTTP Error %d: %s" %
|
|
(response.status_code, response.reason))
|
|
|
|
if 200 <= code < 300:
|
|
return json_response
|
|
elif (code == DUPLICATE_RESPONSE["code"] and
|
|
DUPLICATE_RESPONSE["message"] in message):
|
|
raise TroveboxDuplicateError("Code %d: %s" % (code, message))
|
|
else:
|
|
raise TroveboxError("Code %d: %s" % (code, message))
|