def handler_wrapper(event, context, **kwargs):
token_scopes = utils.deep_get(event, 'requestContext', 'authorizer', 'scopes')
if not token_scopes:
raise HTTPResponseException('Invalid token scopes: missing!')
if not all((s in token_scopes for s in string_scope_list)):
logger.warning(f'There is a required scope [{scope_list}] missing from token scopes [{token_scopes}].')
raise HTTPResponseException('access_token has insufficient access.', statusCode=403)
return handler(event, context, **kwargs)
def handler_wrapper(event, context, **kwargs):
try:
return handler(event, context, **kwargs)
except Exception as err:
logger.error('Lambda Event : {}'.format(event))
logger.exception('{}:{}'.format(type(err), err))
raise HTTPResponseException(f'Could not complete {handler.__name__}')
def handler_wrapper(event, context, **kwargs):
domain = utils.deep_get(event, 'requestContext', 'authorizer', 'domain')
if not domain:
logger.error('Domain requestContext variable missing.')
raise HTTPResponseException('Invalid domain.')
kwargs['domain'] = domain
return handler(event, context, **kwargs)
def handler_wrapper(event, context, **kwargs):
sub = utils.deep_get(event, 'requestContext', 'authorizer', 'sub')
if not sub:
logger.error('Sub requestContext variable missing.')
raise HTTPResponseException('Invalid sub.')
kwargs['sub'] = sub
return handler(event, context, **kwargs)
def handler_wrapper(event, context, **kwargs):
try:
event_body = json.loads(event.get('body'))
except json.JSONDecodeError:
raise HTTPResponseException(error or 'Invalid event.body: cannot decode json.', statusCode=400)
body_required = {k: event_body.get(k) for k in (required if required else {})}
if not all((v is not None for v in body_required.values())):
logger.error(f'There is a required key in [{required}] missing from event.body [{event_body}].')
raise HTTPResponseException(error or 'Invalid event.body: missing required key.', statusCode=400)
body_optional = {k: event_body.get(k) for k in (optional if optional else {})}
handler_body = {}
handler_body.update(**body_required, **body_optional)
kwargs['body'] = handler_body
return handler(event, context, **kwargs)
def handler_wrapper(event, context, **kwargs):
for param in required_querystring if required_querystring else {}:
value = utils.deep_get(event, 'queryStringParameters', param)
if not value:
logger.error(f'queryStringParameter [{param}] missing from event [{event}].')
raise HTTPResponseException(error or f'Invalid {param}.', statusCode=400)
kwargs[param] = value
for param in optional_querystring if optional_querystring else {}:
value = utils.deep_get(event, 'queryStringParameters', param)
if value:
kwargs[param] = value
for param in path if path else {}:
value = utils.deep_get(event, 'pathParameters', param)
if not value:
logger.error(f'pathParameter [{param}] missing from event [{event}].')
raise HTTPResponseException(error or f'Invalid {param}.', statusCode=400)
kwargs[param] = value
return handler(event, context, **kwargs)
def function_wrapper(*args, **kwargs):
for r in required if required else []:
value = os.environ.get(r)
if not value:
raise HTTPResponseException(f'{r} environment variable missing.')
kwargs[r] = value
for o in optional if optional else []:
kwargs[o] = os.environ.get(o)
return handler(*args, **kwargs)
def handler_wrapper(event, context, **kwargs):
config_bucket = os.environ['CONFIG']
encrypt_key_arn = os.environ.get('ENCRYPT_KEY_ARN')
conn = conf.conn(encrypt_key_arn)
try:
settings = conf.load_or_create(conn, config_bucket, config_file) if create else conf.load(
conn, config_bucket, config_file)
except Exception as err:
logger.exception(err)
logger.error('Failed to load or create configuration.')
raise HTTPResponseException('Failed to load configuration.', statusCode=503)
configuration = {
'load': lambda: settings or {},
'save': functools.partial(conf.save, conn, config_bucket, config_file),
}
return handler(event, context, configuration=configuration, **kwargs)
def handler_wrapper(event, context, **kwargs):
logger.debug(f'Checking origin for event: {event}')
# Check Origin
request_origin = utils.deep_get(event, 'headers', 'origin', ignore_case=True)
if not any(re.match(o, str(request_origin)) for o in origins):
logger.warning(f'Invalid request origin: {request_origin}')
raise HTTPResponseException('Unknown origin.', statusCode=403)
# call handler
kwargs['request_origin'] = request_origin
response = handler(event, context, **kwargs)
if not isinstance(response, dict):
raise Exception(
f'Unsupported response type {type(response)}; response must be dict for *_response decorators.')
# add origin to response headers
current_headers = response.get('headers', {})
cors_headers = {'Access-Control-Allow-Origin': request_origin,
'Access-Control-Allow-Credentials': 'true'}
response['headers'] = {**current_headers, **cors_headers}
return response
def http_exception_handler(e, c, **kwargs):
raise HTTPResponseException(body=expected_body,
statusCode=expected_statuscode)
def handler_wrapper(event, context, **kwargs):
if kwargs.get('PAUSE'):
logger.warning('Function paused')
raise HTTPResponseException('info: paused', statusCode=503)
return handler(event, context, **kwargs)