def get(receiver_address, sender_address, block_number):
dbot_address = receiver_address
dbot_service = dbot.get_service(dbot_address)
if not dbot_service:
abort(404, message="dbot not found")
ret, status_code = dbot_service.channel_detail.get(sender_address, block_number)
if status_code != 200:
abort(status_code, message=ret)
return ret, status_code
def proxy(dbot_address, uri, proxy_uri=None):
# proxy requst to api server host
dbot_service = dbot.get_service(dbot_address)
if not dbot_service:
raise InvalidUsage('dbot address not found', status_code=404)
url = '{}://{}/{}'.format(dbot_service.protocol, dbot_service.api_host,
remove_slash_prefix(uri))
headers = {key: value for (key, value) in request.headers if key != 'Host'}
# Pass original Referer for subsequent resource requests
headers["Referer"] = url
logger.info("Proxy the API {}: {}, with headers: \n{}".format(
request.method, url, headers))
# Fetch the URL, and stream it back
try:
resp = requests.request(
url=url,
method=request.method,
params=request.args,
headers=headers,
# TODO: Usually it's a bad idea to call get_data() without checking the
# content length first as a client could send dozens of megabytes or more
# to cause memory problems on the server.
data=request.get_data(),
cookies=request.cookies,
allow_redirects=False)
logger.info("Got {} response from {}".format(resp.status_code, url))
excluded_headers = [
'content-encoding', 'content-length', 'transfer-encoding',
'connection'
]
headers = [(name, value) for (name, value) in resp.raw.headers.items()
if name.lower() not in excluded_headers]
return Response(resp.content, resp.status_code, headers)
except Exception as err:
raise InvalidUsage('Cannot proxy the request.\n{}'.format(err),
status_code=400)
def decorated(*args, **kwargs):
dbot_address = kwargs.get('dbot_address')
middleware = dbot.get_service(dbot_address).middleware
request.new_method, request.new_args, request.new_headers, request.new_data = middleware(
request.method, request.args, request.headers, request.get_data())
return f(*args, **kwargs)
def __call__(self, environ, start_response):
# this middleware only used for (/call/<dbot_address>/<path:uri>
url_map = Map(
[Rule('/call/<dbot_address>/<path:uri>', endpoint='proxy')])
urls = url_map.bind_to_environ(environ)
try:
endpoint, kwargs = urls.match()
except (NotFound, MethodNotAllowed) as e:
return self.app(environ, start_response)
try:
method = environ['REQUEST_METHOD']
if method == 'OPTIONS':
# if CORS first request, return response
return self.app(environ, start_response)
dbot_address = kwargs['dbot_address']
dbot_address = to_checksum_address(dbot_address)
uri = kwargs['uri']
dbot_service = dbot.get_service(dbot_address)
if not dbot_service:
raise InvalidUsage('dbot address not found', status_code=404)
# Ensure the URI is an approved API endpoint, else abort
price, proxy_uri = _get_endpoint(dbot_service, uri, method)
if price < 0:
logger.error(
"({}: {}) is not an approved API endpoint.".format(
method, uri))
raise InvalidUsage(
"({}: {}) is not an approved API endpoint.".format(
method, uri),
status_code=404)
environ['PATH_INFO'] = '/call/{}/{}'.format(
dbot_address, remove_slash_prefix(proxy_uri))
if price > 0:
# Balance Proof check
ret, code, headers = dbot_service.paywall.access(
price, EnvironHeaders(environ))
if code != 200:
return _make_response(environ, start_response, ret, code,
headers)
logger.info("Balance Proof check is ok.")
middleware_cls = dbot_service.middleware
if middleware_cls:
# load dbot's middleware in runtime
logger.info('init middleware({}) for dbot({})'.format(
middleware_cls, dbot_address))
middleware = middleware_cls(self.app)
return middleware(environ, start_response)
else:
return self.app(environ, start_response)
except InvalidUsage as e:
logger.error('{}'.format(e.message))
return _make_response(environ, start_response,
'{}'.format(e.to_dict()), e.status_code)
except Exception as e:
logger.error('{}'.format(e))
return _make_response(environ, start_response, '{}'.format(e), 500)
def delete(receiver_address, sender_address, block_number):
dbot_address = receiver_address
dbot_service = dbot.get_service(dbot_address)
if not dbot_service:
abort(404, message="dbot not found")
return dbot_service.channel_detail.delete(sender_address, block_number)
def get(receiver_address, sender_address=None):
dbot_address = receiver_address
dbot_service = dbot.get_service(dbot_address)
if not dbot_service:
abort(404, message="dbot not found")
return dbot_service.channel_list.get(sender_address)