def call_jasmin(self, url, params=None):
try:
r = requests.get('%s/%s' % (old_api_uri, url), params=params)
except requests.exceptions.ConnectionError as e:
raise falcon.HTTPInternalServerError(
'Jasmin httpapi connection error',
'Could not connect to Jasmin http api (%s): %s' %
(old_api_uri, e))
except Exception as e:
raise falcon.HTTPInternalServerError(
'Jasmin httpapi unknown error', str(e))
else:
return r.status_code, r.content.strip('"')
def __init__(self,
schema,
target='content',
title='Request data failed validation'):
if isinstance(schema, str):
self.schema = yaml.safe_load(schema)
elif isinstance(schema, dict):
self.schema = schema
else:
raise falcon.HTTPInternalServerError('Bad JSON schema')
if target not in ['content', 'params']:
raise falcon.HTTPInternalServerError('Invalid schema target')
self.target = target
self.title = title
def on_get(self, req, resp, action, conn_id):
# Retrieve URL
web_server_url = self.retrieve_config('base', 'web_server')
if 'Error' in web_server_url:
resp.status = falcon.HTTP_500
raise falcon.HTTPInternalServerError("Internal Server Error",
"Missing Configuration File")
else:
if action == 'delete':
# Form the request URL towards Airflow
req_url = '{}/admin/rest_api/api?api=connections&delete=true&conn_id={}'.format(
web_server_url, conn_id)
else:
self.return_error(
resp, falcon.HTTP_400,
'Invalid Paremeters for Deleting Airflow Connection')
return
response = requests.get(req_url).json()
# Return output
if response["output"]["stderr"]:
resp.status = falcon.HTTP_400
resp.body = response["output"]["stderr"]
return
else:
resp.status = falcon.HTTP_200
resp.body = response["output"]["stdout"]
def on_patch(self, req, resp):
"""Method takes either sparql statement or predicate and object
and updates the Resource.
Args:
req -- Request
resp -- Response
"""
doc_uuid = req.get_param('uuid')
if not doc_uuid:
raise falcon.HTTPMissingParam('uuid')
predicate = req.get_param('predicate') or None
if not predicate:
raise falcon.HTTPMissingParam('predicate')
object_ = req.get_param('object') or None
if not object_:
raise falcon.HTTPMissingParam('object')
doc_type = req.get_param('doc_type') or None
if self.__update__(doc_id=doc_uuid,
doc_type=doc_type,
field=predicate,
value=object_):
resp.status = falcon.HTTP_202
resp.body = json.dumps(True)
else:
raise falcon.HTTPInternalServerError(
"Error with PATCH for {}".format(doc_uuid),
"Failed setting {} to {}".format(predicate, object_))
def on_post(self, req, resp):
"""Creates a diary based on a PDF template"""
LOGGER = logging.getLogger()
resp.set_header('Content-Type', 'text/json')
raw_json = req.stream.read().decode('utf-8')
content = json.loads(raw_json, encoding='utf-8')
try:
# Parse parameters
pdf_template = content.get("pdf_template")
pages = int(content.get("pages"))
starting_date = content.get("date")
email = content.get("email")
font = content.get("font")
a4_diary = create.create_a4_diary(pdf_template,
pages,
starting_date,
email=email,
font=font)
a5_booklet = create.convert_to_a5_booklet(a4_diary)
resp.body = json.dumps([str(a4_diary), str(a5_booklet)])
LOGGER.info("Document created {}".format(pdf_template))
except Exception as e:
LOGGER.error("Error creating document", exc_info=True)
raise falcon.HTTPInternalServerError(
title="Error creating document: " + str(type(e)),
description=(str(e) +
','.join(traceback.format_tb(e.__traceback__))))
def _serialize_json_to_string(self, resp):
if self._has_json(resp):
if not isinstance(resp.json, dict) and \
not isinstance(resp.json, list):
raise falcon.HTTPInternalServerError()
return json.dumps(resp.json)
return json.dumps({})
async def wrapper(self, req, resp, *args, **kwargs):
if req_schema is not None:
m = await req.get_media()
try:
jsonschema.validate(m,
req_schema,
format_checker=jsonschema.FormatChecker())
except jsonschema.ValidationError as e:
raise falcon.HTTPBadRequest('Request data failed validation',
description=e.message)
result = await func(self, req, resp, *args, **kwargs)
if resp_schema is not None:
try:
jsonschema.validate(resp.media,
resp_schema,
format_checker=jsonschema.FormatChecker())
except jsonschema.ValidationError:
raise falcon.HTTPInternalServerError(
'Response data failed validation'
# Do not return 'e.message' in the response to
# prevent info about possible internal response
# formatting bugs from leaking out to users.
)
return result
def on_get(self, req, resp, player_id):
if not self.gs.gameStarted:
raise falcon.HTTPInternalServerError(
"Game Not Started",
"Please start the game before issuing commands")
if (player_id not in self.gs.get_activePlayers()):
raise falcon.HTTPBadRequest(
"Invalid Player Name",
"That player name is not currently playing")
output = {'characters': [], 'weapons': [], 'rooms': []}
for card in self.gs.players[player_id].hand:
if card.type is 1:
output['characters'].append(card.name)
elif card.type is 2:
output['weapons'].append(card.name)
elif card.type is 3:
output['rooms'].append(card.name)
else:
raise falcon.HTTPBadRequest("Invalid Card Used", )
resp.set_header('Powered-By', 'Falcon')
resp.body = json.dumps(output)
resp.status = falcon.HTTP_200
def process_response(self, req, resp, resource, req_succeeded):
if 'result' not in req.context or (resp.data and len(resp.data) > 0):
# If there's no response to process or a different middleware set the response to something, do nothing in this one.
return
result = req.context['result']
if 'data' in result and not 'meta' in result:
resp.body = json.dumps(result['data'])
else:
resp.body = json.dumps(result)
schema = _get_response_schema(resource, req)
if schema is None:
return
try:
jsonschema.validate(req.context['result'], schema)
except jsonschema.exceptions.ValidationError as error:
method_name = {
'POST': 'on_post',
'PUT': 'on_put',
'PATCH': 'on_patch',
'GET': 'on_get',
'DELETE': 'on_delete'
}[req.method]
self.logger.error(
'Blocking proposed response from being sent from {0}.{1}.{2} to client as it does not match the defined schema: {3}'
.format(resource.__module__, resource.__class__.__name__,
method_name, str(error)))
raise falcon.HTTPInternalServerError('Internal Server Error',
'Undisclosed')
def process_request(self, req, resp):
token = req.get_header('Authorization')
if not token:
raise falcon.HTTPUnauthorized('Auth token required',
'',
'',
href='http://docs.example.com/auth')
auth_headers = {'Authorization': token}
auth_response = auth_client.post(headers=auth_headers)
if not auth_response:
raise falcon.HTTPInternalServerError('Server error', 'There was a server error')
if auth_response.status_code == 401:
raise falcon.HTTPUnauthorized('Authorization failed',
'',
'',
href='http://docs.example.com/auth')
user_details = auth_response.json()
if not self._has_permission(user_details):
metrics.incr('authorization.permission_denied')
description = 'You do not have permission to access this resource.'
raise falcon.HTTPForbidden('Permission denied',
description,
href='http://docs.example.com/auth')
metrics.incr('authorization.authorization_success')
req.context['auth_header'] = auth_headers
req.context['user_details'] = user_details
def dispatch_request(req):
# Check if req.stream is consumed, otherwise get POST data.
body = req.context.get('doc') or _get_json_body(req)
logger.debug('Got body: %s' % body)
req_type = get_req_type(body)
intent_maps = req.context['intent_maps']
if req_type == 'LaunchRequest':
return req.context['welcome']
elif req_type == 'IntentRequest':
intent = body['request']['intent']['name']
try:
intent_fn = intent_maps[intent]
except KeyError:
logger.exception(
'No intent function mapping found for intent: %s' % intent)
try:
intent_fn = intent_maps['UnknownIntent']
except KeyError:
logger.exception('UnknownIntent mapping also not found.')
raise falcon.HTTPInternalServerError()
return intent_fn(body)
elif req_type == 'SessionEndedRequest':
logger.info('SessionEndedRequest received. Session ended.')
return None
logger.error('Invalid request type: %s', req_type)
raise falcon.HTTPBadRequest()
def on_post(self,
req,
resp,
dag_id,
run_id=None,
conf=None,
execution_date=None):
# Retrieve URL
web_server_url = self.retrieve_config('base', 'web_server')
if 'Error' in web_server_url:
resp.status = falcon.HTTP_500
raise falcon.HTTPInternalServerError("Internal Server Error",
"Missing Configuration File")
else:
req_url = '{}/api/experimental/dags/{}/dag_runs'.format(
web_server_url, dag_id)
response = requests.post(req_url,
json={
"run_id": run_id,
"conf": conf,
"execution_date": execution_date,
})
if response.ok:
resp.status = falcon.HTTP_200
else:
self.return_error(resp, falcon.HTTP_400, 'Fail to Execute Dag')
return
def __add_stub__(self, label, namespace, pid=None):
"""Internal method takes label, namespace, and an optional pid
creates a new Islandora Object and returns JSON result
Args:
label -- Label for new Islandora Object
namespace -- Namespace for repository
pid -- Optional pid
"""
data = {"label": label}
if pid:
data['pid'] = pid
else:
data["namespace"] = namespace
add_url = "{}/islandora/rest/v1/object".format(self.base_url)
add_object_result = requests.post(add_url, data=data, auth=self.auth)
if add_object_result.status_code > 399:
print("Failed to add {} data={} auth={}".format(add_url, data, self.auth))
raise falcon.HTTPInternalServerError(
"Failed to add Islandora object",
"Failed with url={}, islandora status code={}\n{}".format(
add_url,
add_object_result.status_code,
add_object_result.text))
return add_object_result.json()
def on_post(self, req, resp, pid, dsid=None):
env = req.env
env.setdefault('QUERY_STRING', '')
form = cgi.FieldStorage(fp=req.stream, environ=env)
file_item = form['userfile']
data = {"dsid": dsid or "FILE_UPLOAD"}
if "state" in form:
data["state"] = form["state"].value
else:
data["state"] = "A"
if "control_group" in form:
data["controlGroup"] = form['control_group'].value
else:
data["controlGroup"] = "M"
if "label" in form:
data["label"] = form["label"].value
else:
data["label"] = file_item.name
if "mime_type" in form:
data["mimeType"] = form["mime_type"].value
else:
data["mimeType"] = 'application/octet-stream'
if self.__add__(data, file_item.file, pid, dsid):
resp.status = falcon.HTTP_201
resp.body = json.dumps({
"message": "Added {} datastream to {}".format(dsid, pid)})
else:
desc = "{} datastream was not added object".format(dsid)
desc += "{}\nusing POST URL={}".format(pid, self.rest_url)
raise falcon.HTTPInternalServerError(
"Failed to add datastream to object",
desc)
def on_get(self, req, resp, customer_id):
try:
# This is the parameter which is going to get passed.
customerId = customer_id
customerPersonalInfo = self.__getCustomerPersonInfo(customerId)
resp.status = falcon.HTTP_200
resp.content_type = falcon.MEDIA_JSON
resp.body = json.dumps({
"result": "success",
"details": customerPersonalInfo
})
except Exception as error:
print(error)
resp.status = falcon.HTTP_500
resp.body = json.dumps({
"result":
"failed",
"details":
falcon.HTTPInternalServerError("Unable to create task")
})
def on_post(self,req,resp):
"""
Handle POST requests.
"""
username = req.media.get('username')
password = req.media.get('password')
# Check if parameters not empty
if None in (username, password):
raise falcon.HTTPBadRequest('Bad Request', 'Invalid Parameters')
# Hash user password
hashed = pbkdf2_sha256.encrypt(password, rounds=200000, salt_size=16)
# Now create main user for account
user = User(username=username, password=hashed)
self.db_conn.add(user)
# Attempt database changes commit
try:
# Create User
self.db_conn.commit()
except SQLAlchemyError as e:
# Rollback Changes
self.db_conn.rollback()
# Send error
logger.error(f'Database Error: (Code: {e.orig.args[0]} Message: {e.orig.args[1]})')
raise falcon.HTTPInternalServerError('Internal Server Error', 'An error ocurred while communicating with the database.')
resp.media = {'success': 'user_created'}
resp.status = falcon.HTTP_201
def _error_handler(self, exc, request, response, params):
"""Handler error"""
if isinstance(exc, falcon.HTTPError):
raise exc
LOG.exception(exc)
raise falcon.HTTPInternalServerError('Internal server error',
six.text_type(exc))
def handle_http_error(exception, req, resp, params):
"""
Simple Falcon responder to log exceptions, before responding to web client
>>> normal_exception = falcon.HTTPNotFound(description='friendly msg')
>>> normal_exception.__cause__ = Exception('technical info')
>>> handle_http_error( normal_exception, None, None, None)
Traceback (most recent call last):
...
falcon.errors.HTTPNotFound
>>> unhandled_exception = Exception("I was not expected!")
>>> handle_http_error( unhandled_exception, None, None, None)
Traceback (most recent call last):
...
falcon.errors.HTTPInternalServerError
"""
if not isinstance(exception, falcon.HTTPError):
#Warning! exception is not an HTTP response, be careful not to expose
# security sensitive internal information
logging.exception( Exception("Unsanitized exception occurred!", exception))#TODO: make this a locally defined class
sanitized = falcon.HTTPInternalServerError(title='500',description="Please try again")
raise get_datatables_editor_exception(sanitized)
# else, intentionally raised (safe) web error
#internally log cause
if exception.__cause__:
logging.exception(exception.__cause__)
logging.exception(exception) #Falcon stack does not seem to include cause.
# raise safe exception to client
raise get_datatables_editor_exception(exception)
def on_post(self, req, resp, player_id):
resp.set_header('Powered-By', 'Falcon')
#resp.body = '{}'
if len(self.gs.playerList) < 2:
raise falcon.HTTPInternalServerError(
"Insufficent Players Registered",
"Not enough players are currently registered. Please register at least 2 players."
)
elif (player_id not in self.gs.get_playerlist()):
raise falcon.HTTPBadRequest(
"Invalid Player Name",
"That player name is not currently playing")
if not self.gs.gameStarted:
character_list = ''
self.gs.init_gamestate()
resp.body = json.dumps(
{'info': " ".join(self.gs.playerListActive)})
resp.status = falcon.HTTP_201
print("The suspect is: " + self.gs.board.caseFile.suspect.name)
print("The room is: " + self.gs.board.caseFile.room.name)
print("The weapon is: " + self.gs.board.caseFile.weapon.name,
flush=True)
else:
resp.body = json.dumps({'info': "Game has started already."})
resp.status = falcon.HTTP_200
def on_get(self, req, resp):
token = req.get_param('token', True)
data = {}
for key in self.data_keys:
data[key] = req.get_param(key, True)
if not self.validate_token(token, data):
raise falcon.HTTPForbidden('Invalid token for these given values',
'')
endpoint = self.config['iris']['hook']['gmail_one_click']
try:
result = self.iclient.post(endpoint, data)
except MaxRetryError:
logger.exception('Hitting iris-api failed for gmail oneclick')
else:
if result.status == 204:
resp.status = falcon.HTTP_204
return
else:
logger.error(
'Unexpected status code from api %s for gmail oneclick',
result.status)
raise falcon.HTTPInternalServerError('Internal Server Error',
'Invalid response from API')
def on_get(self, req, resp):
"""
Handles GET requests for ELB HealthCheck Resource
:param req:
:param resp:
:return:
"""
uptime = int(time.time()) - self.start_time
if self.load_balancer.check_if_model_to_workers_map_is_empty():
resp.status = falcon.HTTP_500
resp.body = "Model To Workers Map is Empty"
raise falcon.HTTPInternalServerError(
'Internal Server Error', 'Model To Workers Map is Empty! ')
resp.status = falcon.HTTP_200
count = self.load_balancer.model_id_request_count
# TODO requests and capacity have to be calculated. They are hardcoded for now
resp.body = json.dumps({
'uptime': uptime,
'requests': count,
'capacity': 100
})
def process_resource(self, req, resp, resource, params):
if not isinstance(resource, self.resource):
return
allowed_methods = ['POST']
if req.method not in allowed_methods:
raise falcon.HTTPMethodNotAllowed(allowed_methods)
# TODO: Validate application ID if intended for this service.
if self.validate:
body = req.context.get('doc') or util._get_json_body(req)
valid_cert = self.validate_request_certificate(req, body)
valid_ts = self.validate_request_timestamp(body)
if not valid_cert or not valid_ts:
logger.error('Failed to validate request.')
raise falcon.HTTPForbidden()
welcome = getattr(resource, 'welcome', None)
req.context['welcome'] = welcome
intent_maps = getattr(resource, 'intent_maps', None)
if intent_maps is None:
logger.error('Missing attribute "intent_maps" in resource.')
raise falcon.HTTPInternalServerError()
req.context['intent_maps'] = intent_maps
def on_post(self, req, resp):
"""
Encodes a diary (tif or zip file) based on a rubric (created in the web interface) and a blank
page of the diary (tif or zip file) present in TEMPLATE_DIR
"""
LOGGER = logging.getLogger()
resp.set_header('Content-Type', 'text/json')
raw_json = req.stream.read().decode('utf-8')
content = json.loads(raw_json, encoding='utf-8')
try:
rubric = content.get("rubric")
diary_path = content.get("diary")
date = content.get("date")
encoded_diary = encode.encode_diary(diary_path, TEMPLATE_DIR,
rubric, date)
resp.body = json.dumps(str(encoded_diary))
LOGGER.info("Document encoded {}".format(encoded_diary.stem))
except Exception as e:
LOGGER.error("Error encoding document", exc_info=True)
raise falcon.HTTPInternalServerError(
title="Error encoding document: " + str(type(e)),
description=(str(e) +
','.join(traceback.format_tb(e.__traceback__))))
def process_response(self, req, resp, resource):
if 'result' not in req.context:
return
resp.body = json.dumps(req.context['result'])
schema = _get_response_schema(resource, req)
if schema is None:
return
try:
schema.validate(req.context['result'])
except jsonschema.exceptions.ValidationError as error:
method_name = {
'POST': 'on_post',
'PUT': 'on_put',
'PATCH': 'on_patch',
'GET': 'on_get',
'DELETE': 'on_delete'
}[req.method]
self.logger.error(
'Blocking proposed response from being sent from {0}.{1}.{2} to client as it does not match the defined schema: {3}'
.format(resource.__module__, resource.__class__.__name__,
method_name, str(error)))
raise falcon.HTTPInternalServerError('Internal Server Error',
'Undisclosed')
def handle(cls, ex, req, resp, params): # pylint: disable=W0613
"""
Rollbacks the DB Session.
In addition, handles the exceptions, logs it and raises the proper status code response.
"""
DBSESSION.rollback()
logger = logging.getLogger()
log_msg = f"{req.method} for {req.relative_uri} {cls.get_payload(req)}"
if isinstance(ex, falcon.HTTPError):
logger.info(
f"Treated error during: {log_msg}. Response status = {ex.status}"
)
pass
elif isinstance(ex, ModelExceptions):
logger.info(
f"Treated error during: {log_msg}. Response status = 400")
ex = falcon.HTTPBadRequest(description=ex.args)
elif isinstance(ex, ObjectNotFound):
logger.info(
f"Treated error during: {log_msg}. Response status = 404")
ex = falcon.HTTPNotFound(description=ex.args)
elif isinstance(ex, IntegrityError):
logger.exception(
f"Database integrity error during: {log_msg}. Response status = 500"
)
ex = falcon.HTTPBadRequest()
else:
logger.exception(
f"Unexpected error during: {log_msg}. Response status = 500")
ex = falcon.HTTPInternalServerError()
raise ex
def on_post(self, request, response):
request._parse_form_urlencoded()
user = None
if request.auth:
user = authenticate_by_token(request.auth)
if user is None:
raise falcon.HTTPUnauthorized('Login required', 'Please login',
['Basic realm="Login Required"'])
if 'owner' not in request.params:
request.params['owner'] = user.id
new_item = self.model(**request.params)
if user.can('read', new_item):
with db.atomic():
try:
new_item.save()
except:
raise falcon.HTTPInternalServerError('Internal error', 'The \
requested operation cannot be completed')
response.status = falcon.HTTP_CREATED
path = '{}/{}'.format(request.path, new_item.id)
s = hinder(new_item.__dict__['_data'], path=path)
response.body = json.dumps(s)
else:
raise falcon.HTTPForbidden('Forbidden access', 'You do not have the \
required permissions for this action')
def on_get(self, req, resp, action, conn_id, protocol, host, port):
# Retrieve URL
web_server_url = self.retrieve_config('base', 'web_server')
if 'Error' in web_server_url:
resp.status = falcon.HTTP_500
raise falcon.HTTPInternalServerError("Internal Server Error",
"Missing Configuration File")
else:
if action == 'add':
# Concatenate to form the connection URL
netloc = ''.join([host, ':', port])
url = (protocol, netloc, '', '', '')
conn_uri = urlparse.urlunsplit(url)
# Form the request URL towards Airflow
req_url = '{}/admin/rest_api/api?api=connections&add=true&conn_id={}&conn_uri={}'.format(
web_server_url, conn_id, conn_uri)
else:
self.return_error(
resp, falcon.HTTP_400,
'Invalid Paremeters for Adding Airflow Connection')
return
response = requests.get(req_url).json()
# Return output
if response["output"]["stderr"]:
resp.status = falcon.HTTP_400
resp.body = response["output"]["stderr"]
return
else:
resp.status = falcon.HTTP_200
resp.body = response["output"]["stdout"]
def on_patch_resource(self, request, response, id=0):
user = None
if request.auth:
user = authenticate_by_token(request.auth)
if user is None:
raise falcon.HTTPUnauthorized('Login required', 'Please login',
['Basic realm="Login Required"'])
try:
item = self.model.get(getattr(self.model, 'id') == id)
except:
description = 'The resource you are looking for does not exist'
raise falcon.HTTPNotFound(title='Not found', description=description)
if user.can('edit', item):
stream = request.stream.read().decode('UTF-8')
parsed_stream = json.loads(stream)
for key in parsed_stream:
setattr(item, key, parsed_stream[key])
with db.atomic():
try:
item.save()
except:
raise falcon.HTTPInternalServerError('Internal error', 'The \
requested operation cannot be completed')
item_dict = item_to_dictionary(self.model, item)
s = hinder(item_dict, path=request.path)
response.body = json.dumps(s)
else:
raise falcon.HTTPForbidden('Forbidden access', 'You do not have the \
required permissions for this action')
def on_post(self, req, resp, *args, **kwargs):
super(ResourceDeleteUserToken, self).on_post(req, resp, *args,
**kwargs)
current_user = req.context["auth_user"]
selected_token_string = req.media["token"]
selected_token = self.db_session.query(UserToken).filter(
UserToken.token == selected_token_string).one_or_none()
if selected_token is not None:
if selected_token.user.id == current_user.id:
try:
self.db_session.delete(selected_token)
self.db_session.commit()
resp.status = falcon.HTTP_200
except Exception as e:
mylogger.critical("{}:{}".format(
messages.error_removing_user_token, e))
raise falcon.HTTPInternalServerError()
else:
raise falcon.HTTPUnauthorized(
description=messages.token_doesnt_belongs_current_user)
else:
raise falcon.HTTPUnauthorized(description=messages.token_not_found)
def on_delete_resource(self, request, response, id=0):
user = None
if request.auth:
user = authenticate_by_token(request.auth)
if user is None:
raise falcon.HTTPUnauthorized('Login required', 'Please login',
['Basic realm="Login Required"'])
try:
item = self.model.get(getattr(self.model, 'id') == id)
except:
description = 'The resource you are looking for does not exist'
raise falcon.HTTPNotFound(title='Not found', description=description)
if user.can('eliminate', item):
try:
with db.atomic():
item.delete_instance()
except:
raise falcon.HTTPInternalServerError('Internal error', 'The \
requested operation cannot be completed')
response.status = falcon.HTTP_NO_CONTENT
else:
raise falcon.HTTPForbidden('Forbidden access', 'You do not have the \
required permissions for this action')
