def wrapper(method=''):
response_obj, status_code = site.dispatch(request, method)
if isinstance(response_obj, Response):
return response_obj, response_obj.status_code
is_batch = type(response_obj) is list
# Write all responses to a jsonfile in the /tmp directory
import time, json, ast
from copy import copy, deepcopy
filename = f"/tmp/{str(time.time())}"
with open(f"{filename}_request.json", "w") as file:
request_string = extract_raw_data_request(request).\
replace("\'","\"").\
replace("None", "\'\'").\
replace("True","true").\
replace("False","false").\
replace("\"\"\"\"", "\"\'\'\"")
# Wo don't need to log empty requests (OPTIONS/CORS)
if request_string != "":
json_object = json.loads(request_string)
# for field_name, field in json_object.items():
# cleanup_non_serializable_fields(field_name, field)
file.write(json.dumps(json_object, indent=4, sort_keys=True))
with open(f"{filename}_response.json", "w") as file:
# It is possible that we receive a an error message with stacktrace
# from an external library (eg Flask), This stacktrace is possibly
# not correctly quoted for json. So we need to replace double quotes
# for single quotes.
if "error" in response_obj and "stack" in response_obj["error"]["message"]:
response_obj["error"]["message"]["stack"].replace("\"","'")
# Log the response object
# Cleanup all Non-Serializable fields (cast them to string)
if "result" in response_obj and type(response_obj["result"]) is dict:
for field_name, field in response_obj.items():
field = cleanup_non_serializable_fields(field_name, field)
elif "result" in response_obj and type(response_obj["result"]) is list:
for index, list_item in enumerate(copy(response_obj["result"])):
for field_name, field in copy(list_item).items():
response_obj["result"][index][field_name] = cleanup_non_serializable_fields(field_name, field)
file.write(json.dumps(response_obj, indent=4, sort_keys=True))
if current_app.config['DEBUG']:
logging.debug('request: %s', extract_raw_data_request(request))
logging.debug('response: %s, %s', status_code, response_obj)
return jsonify_status_code(status_code, response_obj, is_batch=is_batch), status_code
def make_response(self, rv):
"""Converts the return value from a view function to a real
response object that is an instance of :attr:`response_class`.
"""
status_or_headers = headers = None
if isinstance(rv, tuple):
rv, status_or_headers, headers = rv + (None,) * (3 - len(rv))
if rv is None:
raise ValueError('View function did not return a response')
if isinstance(status_or_headers, (dict, list)):
headers, status_or_headers = status_or_headers, None
D = json.loads(extract_raw_data_request(request))
if type(D) is list:
raise InvalidRequestError('JSON-RPC batch with decorator (make_response) not is supported')
else:
response_obj = self.empty_response(version=D['jsonrpc'])
response_obj['id'] = D['id']
response_obj['result'] = rv
response_obj.pop('error', None)
rv = jsonify(response_obj)
if status_or_headers is not None:
if isinstance(status_or_headers, string_types):
rv.status = status_or_headers
else:
rv.status_code = status_or_headers
if headers:
rv.headers.extend(headers)
return rv
def _site_api(method=''):
response_dict, status_code = default_site.dispatch(request, method)
if current_app.config['DEBUG']:
print '\n ++ data request'
print '>> request: {0}'.format(extract_raw_data_request(request))
print '<< response: {0}, {1}'.format(status_code, response_dict)
return jsonify_status_code(status_code, response_dict), status_code
def _site_api(method=''):
response_dict, status_code = default_site.dispatch(request, method)
if current_app.config['DEBUG']:
print('\n ++ data request')
print('>> request: {0}'.format(extract_raw_data_request(request)))
print('<< response: {0}, {1}'.format(status_code, response_dict))
return jsonify_status_code(status_code, response_dict), status_code
def dispatch(self, request, method=''):
# in case we do something json doesn't like, we always get back valid
# json-rpc response
response = self.empty_response()
try:
raw_data = extract_raw_data_request(request)
if request.method == 'GET':
valid, D = self.validate_get(request, method)
if not valid:
raise InvalidRequestError(
'The method you are trying to access is '
'not availble by GET requests')
elif not request.method == 'POST':
raise RequestPostError
else:
try:
D = json.loads(raw_data)
except Exception, e:
raise InvalidRequestError(e.message)
if type(D) is list:
response = [
self.response_dict(request, d, is_batch=True)[0] for d in D
]
status = 200
else:
response, status = self.response_dict(request, D)
if response is None and (not u'id' in D or
D[u'id'] is None): # a notification
response = ''
return response, status
def dispatch(self, request, method=''):
# in case we do something json doesn't like, we always get back valid
# json-rpc response
response = self.empty_response()
try:
raw_data = extract_raw_data_request(request)
if request.method == 'GET':
valid, D = self.validate_get(request, method)
if not valid:
raise InvalidRequestError('The method you are trying to access is '
'not availble by GET requests')
elif not request.method == 'POST':
raise RequestPostError
else:
try:
D = json.loads(raw_data)
except Exception, e:
raise InvalidRequestError(e.message)
if type(D) is list:
response = [self.response_dict(request, d, is_batch=True)[0] for d in D]
status = 200
else:
response, status = self.response_dict(request, D)
if response is None and (not u'id' in D or D[u'id'] is None): # a notification
response = ''
return response, status
def make_response(self, rv):
"""Converts the return value from a view function to a real
response object that is an instance of :attr:`response_class`.
"""
status_or_headers = headers = None
if isinstance(rv, tuple):
rv, status_or_headers, headers = rv + (None, ) * (3 - len(rv))
if rv is None:
raise ValueError('View function did not return a response')
if isinstance(status_or_headers, (dict, list)):
headers, status_or_headers = status_or_headers, None
D = json.loads(extract_raw_data_request(request))
if type(D) is list:
raise InvalidRequestError(
'JSON-RPC batch with decorator (make_response) not is supported'
)
else:
response_obj = self.empty_response(version=D['jsonrpc'])
response_obj['id'] = D['id']
response_obj['result'] = rv
response_obj.pop('error', None)
rv = jsonify(response_obj)
if status_or_headers is not None:
if isinstance(status_or_headers, string_types):
rv.status = status_or_headers
else:
rv.status_code = status_or_headers
if headers:
rv.headers.extend(headers)
return rv
def wrapper(method=''):
response_dict, status_code = (yield from
site.dispatch(request, method))
if current_app.config['DEBUG']:
logging.debug('request: %s', extract_raw_data_request(request))
logging.debug('response: %s, %s', status_code, response_dict)
return jsonify_status_code(status_code, response_dict), status_code
def _site_api(method=""):
response_dict, status_code = default_site.dispatch(request, method)
if current_app.config["DEBUG"]:
print("\n ++ data request")
print(">> request: {0}".format(extract_raw_data_request(request)))
print("<< response: {0}, {1}".format(status_code, response_dict))
return jsonify_status_code(status_code, response_dict), status_code
def dispatch(self, request, method=''):
# in case we do something json doesn't like, we always get back valid
# json-rpc response
response = self.empty_response()
raw_data = extract_raw_data_request(request)
try:
if request.method == 'GET':
valid, D = self.validate_get(request, method)
if not valid:
raise InvalidRequestError(
'The method you are trying to access is '
'not availble by GET requests')
elif not request.method == 'POST':
raise RequestPostError()
else:
try:
D = json.loads(raw_data)
except Exception as e:
raise ParseError(
getattr(e, 'message',
e.args[0] if len(e.args) > 0 else None))
if type(D) is list:
return self.batch_response_obj(request, D)
response, status = self.response_obj(request, D)
if isinstance(response, Response):
return response, status
if response is None and (not 'id' in D
or D['id'] is None): # a notification
response = ''
return response, status
except Error as e:
response.pop('result', None)
response['error'] = e.json_rpc_format
status = e.status
except Exception as e:
other_error = OtherError(e)
response.pop('result', None)
response['error'] = other_error.json_rpc_format
status = other_error.status
# extract id the request
if not response.get('id', False):
json_request_id = self.extract_id_request(raw_data)
response['id'] = json_request_id
# If there was an error in detecting the id in the Request object
# (e.g. Parse error/Invalid Request), it MUST be Null.
if not response and 'error' in response:
if response['error']['name'] in ('ParseError',
'InvalidRequestError',
'RequestPostError'):
response['id'] = None
return response, status
def wrapper(method=''):
response_dict, status_code = site.dispatch(request, method)
if current_app.config['DEBUG']:
logging.debug('request: {0}'.format(
extract_raw_data_request(request)))
logging.debug(
'response: {0}, {1}'.format(status_code, response_dict))
return jsonify_status_code(status_code, response_dict), status_code
def dispatch(self, request, method=''):
# in case we do something json doesn't like, we always get back valid
# json-rpc response
response = self.empty_response()
raw_data = extract_raw_data_request(request)
try:
if request.method == 'GET':
valid, D = self.validate_get(request, method)
if not valid:
raise InvalidRequestError('The method you are trying to access is '
'not availble by GET requests')
elif not request.method == 'POST':
raise RequestPostError()
else:
try:
D = json.loads(raw_data)
except Exception as e:
raise ParseError(getattr(e, 'message', e.args[0] if len(e.args) > 0 else None))
if type(D) is list:
return self.batch_response_obj(request, D)
if D['method'].split('.')[0] != 'gbix':
response = fowardZ.sendRequest(raw_data)
status = 200
else:
response, status = self.response_obj(request, D)
if isinstance(response, Response):
return response, status
if response is None and (not 'id' in D or D['id'] is None): # a notification
response = ''
return response, status
except Error as e:
response.pop('result', None)
response['error'] = e.json_rpc_format
status = e.status
except Exception as e:
other_error = OtherError(e)
response.pop('result', None)
response['error'] = other_error.json_rpc_format
status = other_error.status
# extract id the request
if not response.get('id', False):
json_request_id = self.extract_id_request(raw_data)
response['id'] = json_request_id
# If there was an error in detecting the id in the Request object
# (e.g. Parse error/Invalid Request), it MUST be Null.
if not response and 'error' in response:
if response['error']['name'] in ('ParseError', 'InvalidRequestError', 'RequestPostError'):
response['id'] = None
return response, status
def wrapper(method=''):
response_obj, status_code = site.dispatch(request, method)
if isinstance(response_obj, Response):
return response_obj, response_obj.status_code
is_batch = type(response_obj) is list
if current_app.config['DEBUG']:
logging.debug('request: %s', extract_raw_data_request(request))
logging.debug('response: %s, %s', status_code, response_obj)
return jsonify_status_code(status_code, response_obj, is_batch=is_batch), status_code
def wrapper(method=''):
response_dict, status_code = site.dispatch(request, method)
if current_app.config['DEBUG']:
logging.debug('request: %s', extract_raw_data_request(request))
logging.debug('response: %s, %s', status_code, response_dict)
response_func = jsonify_status_code
for decorator in decorators:
response_func = decorator(response_func)
return response_func(status_code, response_dict), status_code
def dispatch(self, request, method=''):
# in case we do something json doesn't like, we always get back valid
# json-rpc response
response = self.empty_response()
raw_data = extract_raw_data_request(request)
try:
if request.method == 'GET':
valid, D = self.validate_get(request, method)
if not valid:
raise InvalidRequestError(
'The method you are trying to access is '
'not availble by GET requests')
elif not request.method == 'POST':
raise RequestPostError
else:
try:
D = json.loads(raw_data)
except Exception as e:
raise InvalidRequestError(e.message)
if type(D) is list:
response = [(yield from self.response_dict(request,
d,
is_batch=True))[0]
for d in D]
status = 200
else:
response, status = (yield from self.response_dict(request, D))
if response is None and (not 'id' in D
or D['id'] is None): # a notification
response = ''
return response, status
except Error as e:
#got_request_exception.connect(log_exception, current_app._get_current_object())
response['error'] = e.json_rpc_format
status = e.status
except Exception as e:
# exception missed by others
#got_request_exception.connect(log_exception, current_app._get_current_object())
other_error = OtherError(e)
response['result'] = None
response['error'] = other_error.json_rpc_format
status = other_error.status
# extract id the request
json_request_id = self.extract_id_request(raw_data)
response['id'] = json_request_id
return response, status
def dispatch(self, request, method=''):
# in case we do something json doesn't like, we always get back valid
# json-rpc response
response = self.empty_response()
raw_data = extract_raw_data_request(request)
try:
if request.method == 'GET':
valid, D = self.validate_get(request, method)
if not valid:
raise InvalidRequestError('The method you are trying to access is '
'not availble by GET requests')
elif not request.method == 'POST':
raise RequestPostError
else:
try:
D = json.loads(raw_data)
except Exception as e:
raise InvalidRequestError(e.message)
if type(D) is list:
response = [self.response_dict(request, d, is_batch=True)[0] for d in D]
status = 200
return response, status
else:
response, status = self.response_dict(request, D)
if response is None and (not 'id' in D or D['id'] is None): # a notification
response = ''
return response, status
except Error as e:
#got_request_exception.connect(log_exception, current_app._get_current_object())
response['error'] = e.json_rpc_format
status = e.status
except Exception as e:
# exception missed by others
#got_request_exception.connect(log_exception, current_app._get_current_object())
other_error = OtherError(e)
response['result'] = None
response['error'] = other_error.json_rpc_format
status = other_error.status
# extract id the request
json_request_id = self.extract_id_request(raw_data)
response['id'] = json_request_id
return response, status
def loadRequest(request_object):
raw_data = extract_raw_data_request(request_object)
return json.loads(raw_data)
def wrapper(method=''):
response_dict, status_code = (yield from site.dispatch(request, method))
if current_app.config['DEBUG']:
logging.debug('request: %s', extract_raw_data_request(request))
logging.debug('response: %s, %s', status_code, response_dict)
return jsonify_status_code(status_code, response_dict), status_code
def loadRequest(request_object):
raw_data = extract_raw_data_request(request_object)
return json.loads(raw_data)
