def get_result(dbinstance, project_id, run_id, token):
result_type = db.get_project_column(dbinstance, project_id, 'result_type')
auth_token_type = get_authorization_token_type_or_abort(project_id, token)
if result_type == 'mapping':
logger.info("Mapping result being returned")
result = db.get_run_result(dbinstance, run_id)
return {"mapping": result}
elif result_type == 'groups':
logger.info("Groups result being returned")
result = db.get_run_result(dbinstance, run_id)
return {"groups": result}
elif result_type == 'similarity_scores':
logger.info("Similarity result being returned")
return get_similarity_score_result(dbinstance, run_id)
elif result_type == 'permutations':
logger.info("Permutation result being returned")
return get_permutations_result(project_id, run_id, dbinstance, token,
auth_token_type)
else:
logger.warning("Unimplemented result type")
safe_fail_request(500, message='Project has unknown result type')
def authorise_get_request(project_id):
if request.headers is None or 'Authorization' not in request.headers:
safe_fail_request(401, message="Authentication token required")
auth_header = request.headers.get('Authorization')
dp_id = None
# Check the resource exists
abort_if_project_doesnt_exist(project_id)
with DBConn() as dbinstance:
project_object = db.get_project(dbinstance, project_id)
logger.info("Checking credentials")
if project_object['result_type'] == 'mapping' or project_object[
'result_type'] == 'similarity_scores':
# Check the caller has a valid results token if we are including results
abort_if_invalid_results_token(project_id, auth_header)
elif project_object['result_type'] == 'permutations':
dp_id = get_authorization_token_type_or_abort(project_id, auth_header)
else:
safe_fail_request(500, "Unknown error")
return dp_id, project_object
def get(project_id, run_id):
log = logger.bind(pid=project_id, rid=run_id)
parent_span = g.flask_tracer.get_span()
log.debug("request run status")
with opentracing.tracer.start_span('check-auth',
child_of=parent_span) as span:
# Check the project and run resources exist
abort_if_run_doesnt_exist(project_id, run_id)
# Check the caller has a valid results token. Yes it should be renamed.
auth_token_type = get_authorization_token_type_or_abort(
project_id, request.headers.get('Authorization'))
log.debug(
"Run status authorized using {} token".format(auth_token_type))
with opentracing.tracer.start_span('get-status-from-db',
child_of=parent_span) as span:
dbinstance = get_db()
run_status = db.get_run_status(dbinstance, run_id)
project_in_error = db.get_encoding_error_count(dbinstance,
project_id) > 0
span.set_tag('stage', run_status['stage'])
run_type = RUN_TYPES[run_status['type']]
state = 'error' if project_in_error else run_status['state']
stage = run_status['stage']
status = {
"state": state,
"time_added": run_status['time_added'],
"stages": run_type['stages'],
"current_stage": {
"number":
stage,
"description":
run_type['stage_descriptions'].get(
stage, "there is no description for this stage")
}
}
# trying to get progress if available
if stage == 1:
# waiting for CLKs
abs_val = db.get_number_parties_uploaded(dbinstance, project_id)
max_val = db.get_project_column(dbinstance, project_id, 'parties')
elif stage == 2:
# Computing similarity
abs_val = cache.get_progress(run_id)
if abs_val is not None:
max_val = db.get_total_comparisons_for_project(
dbinstance, project_id)
else:
# Solving for mapping (no progress)
abs_val = None
if abs_val is not None:
progress = {
'absolute': abs_val,
'relative': (abs_val / max_val) if max_val != 0 else 0,
}
if progress['relative'] > 1.0:
log.warning('oh no. more than 100% ??? abs: {}, max: {}'.format(
abs_val, max_val))
if run_status['stage'] in run_type['stage_progress_descriptions']:
progress['description'] = run_type['stage_progress_descriptions'][
run_status['stage']]
status["current_stage"]["progress"] = progress
if state == 'completed':
status["time_started"] = run_status['time_started']
status["time_completed"] = run_status['time_completed']
return completed().dump(status)
elif state == 'running' or state == 'queued' or state == 'created':
status["time_started"] = run_status['time_started']
return running().dump(status)
elif state == 'error':
log.warning(
'handling the run status for state "error" is not implemented')
return error().dump(status)