def test_subclass_mapped_by_base_class(self):
expected_message = "Single Exception Message"
mapper = ExceptionMapper()
mapper.message_map[RuntimeError] = (expected_message, mapper.format_default)
err = MyRuntimeError("Testing base class")
self.assertEquals(expected_message, mapper.get_message(err))
def test_single_mapped_exception(self):
expected_message = "Single Exception Message"
mapper = ExceptionMapper()
mapper.message_map[RuntimeError] = (expected_message, mapper.format_default)
err = RuntimeError("Testing")
self.assertEqual(expected_message, mapper.get_message(err))
def test_restlib_exception_uses_custom_message(self):
expected_message = "Expected MESSAGE"
mapper = ExceptionMapper()
err = RestlibException(404, expected_message)
self.assertEqual("HTTP error code 404: %s" % expected_message,
mapper.get_message(err))
def test_search_for_base_class_with_gaps(self):
mapper = ExceptionMapper()
expected_message = "RuntimeError message"
mapper.message_map[RuntimeError] = (expected_message, mapper.format_default)
err = MyRuntimeError("Logged Only")
self.assertEqual(expected_message, mapper.get_message(err))
def test_subclass_mapped_by_base_class(self):
expected_message = "Single Exception Message"
mapper = ExceptionMapper()
mapper.message_map[RuntimeError] = (expected_message, mapper.format_default)
err = MyRuntimeError("Testing base class")
self.assertEqual(expected_message, mapper.get_message(err))
def test_can_support_old_style_classes(self):
expected_message = "Old style class"
mapper = ExceptionMapper()
mapper.message_map[OldStyleClass] = (expected_message, mapper.format_default)
err = OldStyleClass()
self.assertEqual(expected_message, mapper.get_message(err))
def test_can_support_old_style_classes(self):
expected_message = "Old style class"
mapper = ExceptionMapper()
mapper.message_map[OldStyleClass] = (expected_message, mapper.format_default)
err = OldStyleClass()
self.assertEquals(expected_message, mapper.get_message(err))
def test_search_for_base_class_with_gaps(self):
mapper = ExceptionMapper()
expected_message = "RuntimeError message"
mapper.message_map[RuntimeError] = (expected_message, mapper.format_default)
err = MyRuntimeError("Logged Only")
self.assertEquals(expected_message, mapper.get_message(err))
def test_single_mapped_exception(self):
expected_message = "Single Exception Message"
mapper = ExceptionMapper()
mapper.message_map[RuntimeError] = (expected_message, mapper.format_default)
err = RuntimeError("Testing")
self.assertEquals(expected_message, mapper.get_message(err))
def test_subclass_preferred_over_base_class(self):
expected_message = "Subclass Exception Message"
mapper = ExceptionMapper()
mapper.message_map[RuntimeError] = ("RuntimeError message", mapper.format_default)
mapper.message_map[MyRuntimeErrorBase] = ("MyRuntimeErrorBase message", mapper.format_default)
mapper.message_map[MyRuntimeError] = (expected_message, mapper.format_default)
err = MyRuntimeError("Logged Only")
self.assertEqual(expected_message, mapper.get_message(err))
def test_subclass_preferred_over_base_class(self):
expected_message = "Subclass Exception Message"
mapper = ExceptionMapper()
mapper.message_map[RuntimeError] = ("RuntimeError message", mapper.format_default)
mapper.message_map[MyRuntimeErrorBase] = ("MyRuntimeErrorBase message", mapper.format_default)
mapper.message_map[MyRuntimeError] = (expected_message, mapper.format_default)
err = MyRuntimeError("Logged Only")
self.assertEquals(expected_message, mapper.get_message(err))
def test_can_map_middle_sub_class(self):
expected_message = "MyRuntimeErrorBase message"
mapper = ExceptionMapper()
mapper.message_map[RuntimeError] = ("RuntimeError message", mapper.format_default)
mapper.message_map[MyRuntimeErrorBase] = (expected_message, mapper.format_default)
mapper.message_map[MyRuntimeError] = ("MyRuntimeError message", mapper.format_default)
err = MyRuntimeErrorBase("Logged Only")
self.assertEqual(expected_message, mapper.get_message(err))
def test_can_map_middle_sub_class(self):
expected_message = "MyRuntimeErrorBase message"
mapper = ExceptionMapper()
mapper.message_map[RuntimeError] = ("RuntimeError message", mapper.format_default)
mapper.message_map[MyRuntimeErrorBase] = (expected_message, mapper.format_default)
mapper.message_map[MyRuntimeError] = ("MyRuntimeError message", mapper.format_default)
err = MyRuntimeErrorBase("Logged Only")
self.assertEquals(expected_message, mapper.get_message(err))
def handle_gui_exception(e, msg, parent, format_msg=True, log_msg=None):
"""
Handles an exception for the gui by logging the stack trace and
displaying a user-friendly internationalized message.
e = either an exception or a tuple returned from sys.exc_info()
msg = User friendly message to display in GUI.
parent = Parent window where the error originates.
log_msg = Optional message to be logged in addition to stack trace.
format_msg = if true, string sub the exception error in the msg
"""
if isinstance(e, tuple):
if not log_msg:
log_msg = str(e[1])
log.error(log_msg, exc_info=e)
# Get the class instance of the exception
e = e[1]
else:
if log_msg:
log.error(log_msg)
log.exception(e)
exception_mapper = ExceptionMapper()
mapped_message = exception_mapper.get_message(e)
if mapped_message:
if isinstance(e, connection.RestlibException):
# If this exception's code is in the 200 range (such as 202 ACCEPTED)
# we're going to ignore the message we were given and just display
# the message from the server as an info dialog. (not an error)
if 200 < int(e.code) < 300:
message = linkify(mapped_message)
messageWindow.InfoDialog(messageWindow.wrap_text(message))
else:
try:
if format_msg:
message = msg % linkify(mapped_message)
else:
message = linkify(mapped_message)
except Exception:
message = msg
show_error_window(message, parent=parent)
else:
show_error_window(mapped_message, parent)
else:
#catch-all, try to interpolate and if it doesn't work out, just display the message
try:
interpolated_str = msg % e
show_error_window(interpolated_str, parent=parent)
except Exception:
show_error_window(msg, parent=parent)
def handle_gui_exception(e, msg, parent, format_msg=True, log_msg=None):
"""
Handles an exception for the gui by logging the stack trace and
displaying a user-friendly internationalized message.
e = either an exception or a tuple returned from sys.exc_info()
msg = User friendly message to display in GUI.
parent = Parent window where the error originates.
log_msg = Optional message to be logged in addition to stack trace.
format_msg = if true, string sub the exception error in the msg
"""
if isinstance(e, tuple):
if not log_msg:
log_msg = str(e[1])
log.error(log_msg, exc_info=e)
# Get the class instance of the exception
e = e[1]
else:
if log_msg:
log.error(log_msg)
log.exception(e)
exception_mapper = ExceptionMapper()
mapped_message = exception_mapper.get_message(e)
if mapped_message:
if isinstance(e, connection.RestlibException):
# If this exception's code is in the 200 range (such as 202 ACCEPTED)
# we're going to ignore the message we were given and just display
# the message from the server as an info dialog. (not an error)
if 200 < int(e.code) < 300:
message = linkify(mapped_message)
messageWindow.InfoDialog(messageWindow.wrap_text(message))
else:
try:
if format_msg:
message = msg % linkify(mapped_message)
else:
message = linkify(mapped_message)
except Exception:
message = msg
show_error_window(message, parent=parent)
else:
show_error_window(mapped_message, parent)
else:
#catch-all, try to interpolate and if it doesn't work out, just display the message
try:
interpolated_str = msg % e
show_error_window(interpolated_str, parent=parent)
except Exception:
show_error_window(msg, parent=parent)
def format_exception(e, msg, format_msg=True, log_msg=None):
if isinstance(e, tuple):
log.error(log_msg, exc_info=e)
# Get the class instance of the exception
e = e[1]
message = None
exception_mapper = ExceptionMapper()
mapped_message = exception_mapper.get_message(e)
if mapped_message:
message = format_mapped_message(e, msg, mapped_message, format_msg=format_msg)
else:
message = format_interpolated_message(e, msg, mapped_message, format_msg=format_msg)
return message
def format_exception(e, msg, format_msg=True, log_msg=None):
if isinstance(e, tuple):
log.error(log_msg, exc_info=e)
# Get the class instance of the exception
e = e[1]
message = None
exception_mapper = ExceptionMapper()
mapped_message = exception_mapper.get_message(e)
if mapped_message:
message = format_mapped_message(e, msg, mapped_message, format_msg=format_msg)
else:
message = format_interpolated_message(e, msg, mapped_message, format_msg=format_msg)
return message
def handle_exception(msg, ex):
# On Python 2.4 and earlier, sys.exit triggers a SystemExit exception,
# which can land us into this block of code. We do not want to handle
# this or print any messages as the caller would already have done so,
# so just re-throw and let Python have at it.
if isinstance(ex, SystemExit):
raise ex
# GoneException will be handled uniformly for every command except unregister.
if isinstance(ex, connection.GoneException):
raise ex
log.error(msg)
log.exception(ex)
exception_mapper = ExceptionMapper()
mapped_message: str = exception_mapper.get_message(ex)
system_exit(os.EX_SOFTWARE, mapped_message)
def test_returns_none_when_no_mapped_exception_present(self):
mapper = ExceptionMapper()
self.assertEqual(None, mapper.get_message(RuntimeError()))
def test_return_str_when_no_mapped_exception(self):
expected_message = "Expected message"
mapper = ExceptionMapper()
err = RuntimeError(expected_message)
self.assertEqual(expected_message, mapper.get_message(err))
def test_returns_none_when_no_mapped_exception_present(self):
mapper = ExceptionMapper()
self.assertEqual(None, mapper.get_message(RuntimeError()))
def test_restlib_exception_uses_custom_message(self):
expected_message = "Expected MESSAGE"
mapper = ExceptionMapper()
err = RestlibException(404, expected_message)
self.assertEqual("HTTP error code 404: %s" % expected_message, mapper.get_message(err))
def _do_command(self):
"""
Executes the command.
"""
self.assert_should_be_registered()
self._validate_options()
# --pool or --file turns off default auto attach
if self.options.pool or self.options.file:
self.auto_attach = False
# Do not try to do auto-attach, when simple content access mode is used
# BZ: https://bugzilla.redhat.com/show_bug.cgi?id=1826300
#
if is_simple_content_access(uep=self.cp, identity=self.identity):
if self.auto_attach is True:
self._print_ignore_auto_attach_mesage()
else:
self._print_ignore_attach_message()
return 0
installed_products_num = 0
return_code = 0
report = None
# TODO: change to if self.auto_attach: else: pool/file stuff
try:
cert_action_client = ActionClient(skips=[PackageProfileActionInvoker])
cert_action_client.update()
cert_update = True
attach_service = attach.AttachService(self.cp)
if self.options.pool:
subscribed = False
for pool in self.options.pool:
# odd html strings will cause issues, reject them here.
if pool.find("#") >= 0:
system_exit(os.EX_USAGE, _("Please enter a valid numeric pool ID."))
try:
ents = attach_service.attach_pool(pool, self.options.quantity)
# Usually just one, but may as well be safe:
for ent in ents:
pool_json = ent["pool"]
print(
_("Successfully attached a subscription for: {name}").format(
name=pool_json["productName"]
)
)
log.debug(
"Attached a subscription for {name}".format(name=pool_json["productName"])
)
subscribed = True
except connection.RestlibException as re:
log.exception(re)
exception_mapper = ExceptionMapper()
mapped_message = exception_mapper.get_message(re)
if re.code == 403:
print(mapped_message) # already subscribed.
elif re.code == 400 or re.code == 404:
print(mapped_message) # no such pool.
else:
system_exit(os.EX_SOFTWARE, mapped_message) # some other error.. don't try again
if not subscribed:
return_code = 1
# must be auto
else:
installed_products_num = len(products.InstalledProducts(self.cp).list())
# if we are green, we don't need to go to the server
self.sorter = inj.require(inj.CERT_SORTER)
if self.sorter.is_valid():
if not installed_products_num:
print(_("No Installed products on system. " "No need to attach subscriptions."))
else:
print(
_(
"All installed products are covered by valid entitlements. "
"No need to update subscriptions at this time."
)
)
cert_update = False
else:
# If service level specified, make an additional request to
# verify service levels are supported on the server:
if self.options.service_level:
consumer = self.cp.getConsumer(self.identity.uuid)
if "serviceLevel" not in consumer:
system_exit(
os.EX_UNAVAILABLE,
_(
"Error: The --servicelevel option is not "
"supported by the server. Did not "
"complete your request."
),
)
attach_service.attach_auto(self.options.service_level)
if self.options.service_level is not None:
# RHBZ 1632797 we should only save the sla if the sla was actually
# specified. The uep and consumer_uuid are None, because service_level was sent
# to candlepin server using attach_service.attach_auto()
save_sla_to_syspurpose_metadata(
uep=None, consumer_uuid=None, service_level=self.options.service_level
)
print(_("Service level set to: {}").format(self.options.service_level))
if cert_update:
report = self.entcertlib.update()
profile_action_client = ProfileActionClient()
profile_action_client.update()
if report and report.exceptions():
print(_("Entitlement Certificate(s) update failed due to the following reasons:"))
for e in report.exceptions():
print("\t-", str(e))
elif self.auto_attach:
if not installed_products_num:
return_code = 1
else:
self.sorter.force_cert_check()
# Make sure that we get fresh status of installed products
status_cache = inj.require(inj.ENTITLEMENT_STATUS_CACHE)
status_cache.load_status(
self.sorter.cp_provider.get_consumer_auth_cp(),
self.sorter.identity.uuid,
self.sorter.on_date,
)
self.sorter.load()
# run this after entcertlib update, so we have the new entitlements
return_code = show_autosubscribe_output(self.cp, self.identity)
except Exception as e:
handle_exception("Unable to attach: {e}".format(e=e), e)
# it is okay to call this no matter what happens above,
# it's just a notification to perform a check
self._request_validity_check()
return return_code