9751803833

Committed 01 Jul 2024 10:18PM UTC coverage: 75.02% (-0.03%) from 75.051%

Build # 9751803833

Build Type

Pull #1154

github

Committed by

m0nhawk

Commit Message

feat: one more fix?

Pull Request Pull Request #1154: feat: capitalization

Run Details

7622 of 10160 relevant lines covered (75.02%)

0.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.74

fence/error_handler.py

import uuid
from http.client import responses as http_responses
from flask import render_template
from werkzeug.exceptions import HTTPException

from authlib.oauth2.rfc6749.errors import OAuth2Error
from cdislogging import get_logger

from fence.errors import APIError
from fence.config import config


logger = get_logger(__name__)


def get_error_response(error):
    details, status_code = get_error_details_and_status(error)
    support_email = config.get("SUPPORT_EMAIL_FOR_ERRORS")
    app_name = config.get("APP_NAME", "Gen3 Data Commons")

    message = details.get("message")

    error_id = _get_error_identifier()
    logger.error(
        "{} HTTP error occured. ID: {}\nDetails: {}".format(
            status_code, error_id, str(details)
        )
    )

    # don't include internal details in the public error message
    # to do this, only include error messages for known http status codes
    # that are less that 500
    valid_http_status_codes = [
        int(code) for code in list(http_responses.keys()) if int(code) < 500
    ]
    try:
        status_code = int(status_code)
        if status_code not in valid_http_status_codes:
            message = None
    except (ValueError, TypeError):
        # this handles case where status_code is NOT a valid integer (e.g. HTTP status code)
        message = None
        status_code = 500

    status_code_message = http_responses.get(status_code, "Unknown error code.")

    return (
        render_template(
            "error.html",
            app_name=app_name,
            status_code=status_code,
            status_code_message=status_code_message,
            support_email=support_email,
            error_id=error_id,
            message=message,
        ),
        status_code,
    )


def get_error_details_and_status(error):
    message = error.message if hasattr(error, "message") else str(error)
    if isinstance(error, APIError):
        if hasattr(error, "json") and error.json:
            error.json["message"] = message
            error_response = error.json, error.code
        else:
            error_response = {"message": message}, error.code
    elif isinstance(error, OAuth2Error):
        error_response = {"message": error.description}, error.status_code
    elif isinstance(error, HTTPException):
        error_response = (
            {"message": getattr(error, "description")},
            error.get_response().status_code,
        )
    else:
        logger.exception("Catch exception")
        error_code = 500
        if hasattr(error, "code"):
            error_code = error.code
        elif hasattr(error, "status_code"):
            error_code = error.status_code
        error_response = {"message": message}, error_code

    return error_response


def _get_error_identifier():
    return uuid.uuid4()

1	import uuid	1✔
2	from http.client import responses as http_responses	1✔
3	from flask import render_template	1✔
4	from werkzeug.exceptions import HTTPException	1✔
5
6	from authlib.oauth2.rfc6749.errors import OAuth2Error	1✔
7	from cdislogging import get_logger	1✔
8
9	from fence.errors import APIError	1✔
10	from fence.config import config	1✔
11
12
13	logger = get_logger(__name__)	1✔
14
15
16	def get_error_response(error):	1✔
17	details, status_code = get_error_details_and_status(error)	1✔
18	support_email = config.get("SUPPORT_EMAIL_FOR_ERRORS")	1✔
19	app_name = config.get("APP_NAME", "Gen3 Data Commons")	1✔
20
21	message = details.get("message")	1✔
22
23	error_id = _get_error_identifier()	1✔
24	logger.error(	1✔
25	"{} HTTP error occured. ID: {}\nDetails: {}".format(
26	status_code, error_id, str(details)
27	)
28	)
29
30	# don't include internal details in the public error message
31	# to do this, only include error messages for known http status codes
32	# that are less that 500
33	valid_http_status_codes = [	1✔
34	int(code) for code in list(http_responses.keys()) if int(code) < 500
35	]
36	try:	1✔
37	status_code = int(status_code)	1✔
38	if status_code not in valid_http_status_codes:	1✔
39	message = None	1✔
40	except (ValueError, TypeError):	1✔
41	# this handles case where status_code is NOT a valid integer (e.g. HTTP status code)
42	message = None	1✔
43	status_code = 500	1✔
44
45	status_code_message = http_responses.get(status_code, "Unknown error code.")	1✔
46
47	return (	1✔
48	render_template(
49	"error.html",
50	app_name=app_name,
51	status_code=status_code,
52	status_code_message=status_code_message,
53	support_email=support_email,
54	error_id=error_id,
55	message=message,
56	),
57	status_code,
58	)
59
60
61	def get_error_details_and_status(error):	1✔
62	message = error.message if hasattr(error, "message") else str(error)	1✔
63	if isinstance(error, APIError):	1✔
64	if hasattr(error, "json") and error.json:	1✔
65	error.json["message"] = message	1✔
66	error_response = error.json, error.code	1✔
67	else:
68	error_response = {"message": message}, error.code	1✔
69	elif isinstance(error, OAuth2Error):	1✔
70	error_response = {"message": error.description}, error.status_code	×
71	elif isinstance(error, HTTPException):	1✔
72	error_response = (	1✔
73	{"message": getattr(error, "description")},
74	error.get_response().status_code,
75	)
76	else:
77	logger.exception("Catch exception")	1✔
78	error_code = 500	1✔
79	if hasattr(error, "code"):	1✔
80	error_code = error.code	1✔
81	elif hasattr(error, "status_code"):	1✔
82	error_code = error.status_code	×
83	error_response = {"message": message}, error_code	1✔
84
85	return error_response	1✔
86
87
88	def _get_error_identifier():	1✔
89	return uuid.uuid4()	1✔

uc-cdis / fence / 9751803833

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous