def test_Abort_handles_rpc_errors(self):
action = self.make_action(Abort, NODE_STATUS.DISK_ERASING)
self.patch_rpc_methods(action.node)
exception = self.assertRaises(NodeActionError, action.execute)
self.assertEqual(
get_error_message_for_exception(action.node._stop.side_effect),
str(exception))
def test_PowerOff_handles_rpc_errors(self):
action = self.make_action(PowerOff, NODE_STATUS.DEPLOYED)
self.patch_rpc_methods(action.node)
exception = self.assertRaises(NodeActionError, action.execute)
self.assertEqual(
get_error_message_for_exception(action.node._stop.side_effect),
str(exception))
def process_exception(self, request, exception):
path_matcher = re.compile(settings.API_URL_REGEXP)
if not path_matcher.match(request.path_info):
# Not a path we're handling exceptions for.
# RPCErrorsMiddleware handles non-API requests.
return None
handled_exceptions = self.handled_exceptions.keys()
if exception.__class__ not in handled_exceptions:
# This isn't something we handle; allow processing to
# continue.
return None
status = self.handled_exceptions[exception.__class__]
logging.exception(exception)
error_message = get_error_message_for_exception(exception)
encoding = 'utf-8'
response = HttpResponse(content=error_message.encode(encoding),
status=status,
content_type="text/plain; charset=%s" %
encoding)
if status == http.client.SERVICE_UNAVAILABLE:
response['Retry-After'] = (RETRY_AFTER_SERVICE_UNAVAILABLE)
return response
def __init__(self, error):
# Avoid circular imports.
from maasserver.clusterrpc.utils import get_error_message_for_exception
if isinstance(error, Exception):
super().__init__(get_error_message_for_exception(error))
else:
super().__init__(error)
def test_returns_cluster_name_in_no_connections_error_message(self):
rack = factory.make_RackController()
exception = NoConnectionsAvailable("Unable to connect!",
uuid=rack.system_id)
self.assertEqual(
"Unable to connect to rack controller '%s' (%s); no connections "
"available." % (rack.hostname, rack.system_id),
utils.get_error_message_for_exception(exception))
def test_Release_handles_rpc_errors(self):
action = self.make_action(
Release, NODE_STATUS.ALLOCATED, power_state=POWER_STATE.ON)
self.patch_rpc_methods(action.node)
exception = self.assertRaises(NodeActionError, action.execute)
self.assertEqual(
get_error_message_for_exception(action.node._stop.side_effect),
str(exception))
def test_returns_message_if_exception_has_none(self):
exception_class = random.choice(RPC_EXCEPTIONS)
error_message = ("Unexpected exception: %s. See "
"/var/log/maas/regiond.log "
"on the region server for more information." %
exception_class.__name__)
self.assertEqual(
error_message,
utils.get_error_message_for_exception(exception_class()))
def test_Commission_handles_rpc_errors(self):
self.addCleanup(signals.power.signals.enable)
signals.power.signals.disable()
action = self.make_action(Commission, NODE_STATUS.READY,
POWER_STATE.OFF)
self.patch_rpc_methods(action.node)
exception = self.assertRaises(NodeActionError, action.execute)
self.assertEqual(
get_error_message_for_exception(action.node._start.side_effect),
str(exception))
def test_RescueMode_handles_rpc_errors_for_entering_rescue_mode(self):
action = self.make_action(RescueMode, random.choice([
NODE_STATUS.READY, NODE_STATUS.BROKEN, NODE_STATUS.DEPLOYED,
NODE_STATUS.FAILED_ENTERING_RESCUE_MODE]))
self.patch(action.node, 'start_rescue_mode').side_effect = (
self.make_exception())
exception = self.assertRaises(NodeActionError, action.execute)
self.assertEqual(
get_error_message_for_exception(
action.node.start_rescue_mode.side_effect),
str(exception))
def test_ExitRescueMode_handles_rpc_errors_for_exiting_rescue_mode(self):
action = self.make_action(ExitRescueMode, random.choice([
NODE_STATUS.RESCUE_MODE, NODE_STATUS.ENTERING_RESCUE_MODE,
NODE_STATUS.FAILED_ENTERING_RESCUE_MODE,
NODE_STATUS.FAILED_EXITING_RESCUE_MODE]))
self.patch(action.node, 'stop_rescue_mode').side_effect = (
self.make_exception())
exception = self.assertRaises(NodeActionError, action.execute)
self.assertEqual(
get_error_message_for_exception(
action.node.stop_rescue_mode.side_effect),
str(exception))
def process_exception(self, request, exception):
if not request.path.startswith(settings.API_URL_PREFIX):
# Not a path we're handling exceptions for.
# RPCErrorsMiddleware handles non-API requests.
return None
if exception.__class__ not in self.handled_exceptions:
# This isn't something we handle; allow processing to
# continue.
return None
status = self.handled_exceptions[exception.__class__]
logging.exception(exception)
error_message = get_error_message_for_exception(exception)
encoding = "utf-8"
response = HttpResponse(
content=error_message.encode(encoding),
status=status,
content_type="text/plain; charset=%s" % encoding,
)
if status == http.client.SERVICE_UNAVAILABLE:
response["Retry-After"] = RETRY_AFTER_SERVICE_UNAVAILABLE
return response
def test_ValidationError(self):
exception = ValidationError({NON_FIELD_ERRORS: "Some error"})
self.assertEqual(utils.get_error_message_for_exception(exception),
"Some error")
def test_returns_message_if_exception_has_one(self):
error_message = factory.make_name("exception")
self.assertEqual(
error_message,
utils.get_error_message_for_exception(Exception(error_message)),
)
def _handle_exception(self, request, exception):
logging.exception(exception)
messages.error(
request, "Error: %s" % get_error_message_for_exception(exception))
