class Application(object):
def __init__(self, action_handler, protocol, logger, tracking_api_calls=()):
self.action_handler = action_handler
self.logger = logger
self.helix_api = HelixApi(protocol)
self.tracking_api_calls = tracking_api_calls
self.logger.info('WSGI application %s started', self.__class__.__name__)
def track_api_call(self, s_req, s_resp, remote_addr,
action_name, authorized_data):
pass
def _remote_addr(self, environ):
remote_addr = environ.get('HTTP_X_FORWARDED_FOR')
if remote_addr is None:
remote_addr = environ.get('REMOTE_ADDR', 'undefined')
return remote_addr
def __call__(self, environ, start_response):
raw_data = environ['wsgi.input'].read()
remote_addr = self._remote_addr(environ)
action_name = None
processed_action_data = {}
secured_request = {}
secured_response = {}
try:
action_name, action_data = self.helix_api.handle_request(raw_data)
secured_request = self._secured_request(action_name, action_data)
self.logger.debug('Request from %s: %s' % (remote_addr, secured_request))
processed_action_data = dict(action_data)
req_info = RequestInfo(remote_addr=remote_addr)
raw_response = self.action_handler(action_name, processed_action_data,
req_info)
secured_response = security.sanitize_credentials(raw_response)
self.logger.log(logging.DEBUG, 'Response to %s: %s' % (remote_addr, secured_response))
response = self.helix_api.handle_response(action_name, raw_response)
except ValidationError, e:
action_name, action_data = self.helix_api.handle_request(raw_data, validation=False)
secured_request = self._secured_request(action_name, action_data)
raw_response = response_error(e)
response = self.helix_api.handle_response(action_name, raw_response, validation=False)
self.logger.log(logging.ERROR, 'Request from %s: %s' % (remote_addr, secured_request))
secured_response = security.sanitize_credentials(raw_response)
self.logger.log(logging.ERROR, 'Response to %s: %s. Error: %s' % (remote_addr, secured_response,
';'.join(e.args)))
except RequestProcessingError, e:
raw_response = response_error(e)
response = self.helix_api.handle_response(action_name, raw_response, validation=False)
self.logger.log(logging.ERROR, 'Request from %s: %s' % (remote_addr, secured_request))
secured_response = security.sanitize_credentials(raw_response)
self.logger.log(logging.ERROR, 'Response to %s: %s. Error: %s' % (remote_addr, secured_response,
';'.join(e.args)))
def handle_action(self, action, data, req_info):
api = Api(protocol)
request = dict(data, action=action)
action_name, data = api.handle_request(json.dumps(request))
response = actions.handle_action(action_name, dict(data), req_info)
api.handle_response(action_name, dict(response))
return response
def handle_action(self, action, data):
api = Api(protocol)
request = dict(data, action=action)
action_name, data = api.handle_request(json.dumps(request))
response = actions.handle_action(action_name, dict(data))
api.handle_response(action_name, dict(response))
return response
def test_request_ok(self):
good_data = {
'action': 'add_currency',
'name': 'USD',
'designation': '$',
'cent_factor': 100,
}
raw_data = json.dumps(good_data)
protocol = [
ApiCall('add_currency_request', {'name': Text(), 'designation': Text(), 'cent_factor': int}),
ApiCall('add_currency_response', {'status': Text()}),
]
test_api = Api(protocol)
action_name, data = test_api.handle_request(raw_data)
self.assertEquals(action_name, good_data.pop('action'))
self.assertEquals(data, good_data)
good_response = {'status': 'ok'}
actual_response = json.loads(test_api.handle_response(action_name, good_response))
self.assertEquals(good_response, actual_response)
