def process(self, *args, **kwargs):
"""A template method for all asynchronous tasks.
This method should not be overridden by sub-classes. Rather the
abstract methods below should be overridden.
:param args: List of arguments passed in from the client.
:param kwargs: Dict of arguments passed in from the client.
:return: Returns :class:`FollowOnProcessingStatusDTO` if follow-on
processing (such as retrying this or another task) is
required, otherwise a None return indicates that no
follow-on processing is required.
"""
name = self.get_name()
result = None
# Retrieve the target entity (such as an models.Order instance).
try:
entity = self.retrieve_entity(*args, **kwargs)
except Exception:
# Serious error!
LOG.exception(
u._LE("Could not retrieve information needed to "
"process task '%s'."), name)
raise
# Process the target entity.
try:
result = self.handle_processing(entity, *args, **kwargs)
except Exception as e_orig:
LOG.exception(
u._LE("Could not perform processing for "
"task '%s'."), name)
# Handle failure to process entity.
try:
status, message = api.generate_safe_exception_message(
name, e_orig)
self.handle_error(entity, status, message, e_orig, *args,
**kwargs)
except Exception:
LOG.exception(
u._LE("Problem handling an error for task '%s', "
"raising original "
"exception."), name)
raise e_orig
# Handle successful conclusion of processing.
try:
self.handle_success(entity, result, *args, **kwargs)
except Exception:
LOG.exception(
u._LE("Could not process after successfully "
"executing task '%s'."), name)
raise
return result
def handler(inst, req, resp, *args, **kwargs):
try:
fn(inst, req, resp, *args, **kwargs)
except falcon.HTTPError as f:
LOG.exception('Falcon error seen')
raise f # Already converted to Falcon exception, just reraise
except Exception as e:
status, message = api.generate_safe_exception_message(
operation_name, e)
LOG.exception(message)
api.abort(status, message, req, resp)
def handler(inst, *args, **kwargs):
try:
return fn(inst, *args, **kwargs)
except exc.HTTPError as f:
LOG.exception('Webob error seen')
raise f # Already converted to Webob exception, just reraise
except Exception as e:
status, message = api.generate_safe_exception_message(
operation_name, e)
LOG.exception(message)
pecan.abort(status, message)
def handler(inst, *args, **kwargs):
try:
return fn(inst, *args, **kwargs)
except exc.HTTPError as f:
LOG.exception('Webob error seen')
raise f # Already converted to Webob exception, just reraise
except Exception as e:
status, message = api.generate_safe_exception_message(
operation_name, e)
LOG.exception(message)
pecan.abort(status, message)
def handler(inst, req, resp, *args, **kwargs):
try:
fn(inst, req, resp, *args, **kwargs)
except falcon.HTTPError as f:
LOG.exception('Falcon error seen')
raise f # Already converted to Falcon exception, just reraise
except Exception as e:
status, message = api.generate_safe_exception_message(
operation_name, e)
LOG.exception(message)
api.abort(status, message, req, resp)
def process(self, *args, **kwargs):
"""A template method for all asynchronous tasks.
This method should not be overridden by sub-classes. Rather the
abstract methods below should be overridden.
:param args: List of arguments passed in from the client.
:param kwargs: Dict of arguments passed in from the client.
:return: Returns :class:`FollowOnProcessingStatusDTO` if follow-on
processing (such as retrying this or another task) is
required, otherwise a None return indicates that no
follow-on processing is required.
"""
name = self.get_name()
result = None
# Retrieve the target entity (such as an models.Order instance).
try:
entity = self.retrieve_entity(*args, **kwargs)
except Exception as e:
# Serious error!
LOG.exception(u._LE("Could not retrieve information needed to "
"process task '%s'."), name)
raise e
# Process the target entity.
try:
result = self.handle_processing(entity, *args, **kwargs)
except Exception as e_orig:
LOG.exception(u._LE("Could not perform processing for "
"task '%s'."), name)
# Handle failure to process entity.
try:
status, message = api.generate_safe_exception_message(name,
e_orig)
self.handle_error(entity, status, message, e_orig,
*args, **kwargs)
except Exception:
LOG.exception(u._LE("Problem handling an error for task '%s', "
"raising original "
"exception."), name)
raise e_orig
# Handle successful conclusion of processing.
try:
self.handle_success(entity, result, *args, **kwargs)
except Exception as e:
LOG.exception(u._LE("Could not process after successfully "
"executing task '%s'."), name)
raise e
return result
def handler(inst, *args, **kwargs):
try:
return fn(inst, *args, **kwargs)
except exc.HTTPError:
LOG.exception(u._LE('Webob error seen'))
raise # Already converted to Webob exception, just reraise
# In case PolicyNotAuthorized, we do not want to expose payload by
# logging exception, so just LOG.error
except policy.PolicyNotAuthorized as pna:
status, message = api.generate_safe_exception_message(
operation_name, pna)
LOG.error(message)
pecan.abort(status, message)
except Exception as e:
# In case intervening modules have disabled logging.
LOG.logger.disabled = False
status, message = api.generate_safe_exception_message(
operation_name, e)
LOG.exception(message)
pecan.abort(status, message)
def handler(inst, *args, **kwargs):
try:
return fn(inst, *args, **kwargs)
except exc.HTTPError:
LOG.exception(u._LE('Webob error seen'))
raise # Already converted to Webob exception, just reraise
# In case PolicyNotAuthorized, we do not want to expose payload by
# logging exception, so just LOG.error
except policy.PolicyNotAuthorized as pna:
status, message = api.generate_safe_exception_message(
operation_name, pna)
LOG.error(message)
pecan.abort(status, message)
except Exception as e:
# In case intervening modules have disabled logging.
LOG.logger.disabled = False
status, message = api.generate_safe_exception_message(
operation_name, e)
LOG.exception(message)
pecan.abort(status, message)
def test_handle_secret_content_encoding_not_supported_exception(self):
operation = 'operation'
content_encoding = 'application/octet-stream'
test_excep = secret_store.SecretContentEncodingNotSupportedException(
content_encoding)
status, message = api.generate_safe_exception_message(
operation, test_excep)
self.assertEqual(400, status)
self.assertEqual("operation issue seen - content-encoding of "
"'application/octet-stream' not "
"supported.", message)
def handler(inst, *args, **kwargs):
try:
return fn(inst, *args, **kwargs)
except exc.HTTPError as f:
LOG.exception(u._LE('Webob error seen'))
raise f # Already converted to Webob exception, just reraise
except Exception as e:
# In case intervening modules have disabled logging.
LOG.logger.disabled = False
status, message = api.generate_safe_exception_message(
operation_name, e)
LOG.exception(message)
pecan.abort(status, message)
def handler(inst, *args, **kwargs):
try:
return fn(inst, *args, **kwargs)
except exc.HTTPError:
LOG.exception(u._LE('Webob error seen'))
raise # Already converted to Webob exception, just reraise
except Exception as e:
# In case intervening modules have disabled logging.
LOG.logger.disabled = False
status, message = api.generate_safe_exception_message(
operation_name, e)
LOG.exception(message)
pecan.abort(status, message)
def process(self, *args, **kwargs):
"""A template method for all asynchronous tasks.
This method should not be overridden by sub-classes. Rather the
abstract methods below should be overridden.
:param args: List of arguments passed in from the client.
:param kwargs: Dict of arguments passed in from the client.
:return: None
"""
name = self.get_name()
# Retrieve the target entity (such as an models.Order instance).
try:
entity = self.retrieve_entity(*args, **kwargs)
except Exception as e:
# Serious error!
LOG.exception(u._("Could not retrieve information needed to " "process task '{0}'.").format(name))
raise e
# Process the target entity.
try:
self.handle_processing(entity, *args, **kwargs)
except Exception as e_orig:
LOG.exception(u._("Could not perform processing for " "task '{0}'.").format(name))
# Handle failure to process entity.
try:
status, message = api.generate_safe_exception_message(name, e_orig)
self.handle_error(entity, status, message, e_orig, *args, **kwargs)
except Exception:
LOG.exception(
u._("Problem handling an error for task '{0}', " "raising original " "exception.").format(name)
)
raise e_orig
# Handle successful conclusion of processing.
try:
self.handle_success(entity, *args, **kwargs)
except Exception as e:
LOG.exception(u._("Could not process after successfully executing" " task '{0}'.").format(name))
raise e