def _do_command(self):
if not self.is_registered():
# TODO: Should this use the standard NOT_REGISTERED message?
system_exit(ERR_NOT_REGISTERED_CODE, _("This system is currently not registered."))
print(_("Unregistering from: {hostname}:{port}{prefix}").format(
hostname=conf["server"]["hostname"], port=conf["server"]["port"], prefix=conf["server"]["prefix"]))
try:
unregister.UnregisterService(self.cp).unregister()
except Exception as e:
handle_exception("Unregister failed", e)
# managerlib.unregister reloads the now None provided identity
# so cp_provider provided auth_cp's should fail, like the below
# This block is simply to ensure that the yum repos got updated. If it fails,
# there is no issue since it will most likely be cleaned up elsewhere (most
# likely by the yum plugin)
try:
# there is no consumer cert at this point, a uep object
# is not useful
cleanup_certmgr = UnregisterActionClient()
cleanup_certmgr.update()
except Exception as e:
pass
self._request_validity_check()
# We have new credentials, restart virt-who
restart_virt_who()
print(_("System has been unregistered."))
def test_unregister(self, clean_all_data, mock_path_exists):
"""
Testing normal unregistration process
"""
mock_path_exists.return_value = False # this short-circuits --no-insights path mask check
result = unregister.UnregisterService(self.mock_cp).unregister()
self.assertIsNone(result)
def test_unregister_insights_register_unmask(self, clean_all_data,
mock_path_exists,
mock_readlink, mock_islink,
mock_subprocess_call):
"""
Testing normal unregistration process
"""
mock_path_exists.return_value = True
mock_readlink.return_value = '/dev/null'
mock_islink.return_value = True
mock_open = mock.mock_open()
with mock.patch('rhsmlib.services.unregister.open',
mock_open,
create=True):
result = unregister.UnregisterService(self.mock_cp).unregister()
self.assertIsNone(result)
mock_subprocess_call.assert_called_once_with(
['/usr/bin/systemctl', 'unmask', 'insights-register.path'],
stdout=mock_open(),
stderr=mock_open())
def _perform_unregister(self):
try:
reset_resolver()
unregister.UnregisterService(
self.backend.cp_provider.get_consumer_auth_cp()).unregister()
except Exception as e:
log.error("Error unregistering system with entitlement platform.")
handle_gui_exception(
e,
_("<b>Errors were encountered during unregister.</b>") +
"\n%s\n" +
_("Please see /var/log/rhsm/rhsm.log for more information."),
self.main_window,
log_msg="Consumer may need to be manually cleaned up: %s" %
self.identity.uuid)
# managerlib.unregister removes product and entitlement directories
self.backend.product_dir.__init__()
self.backend.entitlement_dir.__init__()
# We have new credentials, restart virt-who
restart_virt_who()
self.backend.cs.force_cert_check()
def test_unregister(self, clean_all_data):
"""
Testing normal unregistration process
"""
result = unregister.UnregisterService(self.mock_cp).unregister()
self.assertIsNone(result)
def _do_command(self):
"""
Executes the command.
"""
self.log_client_version()
# Always warn the user if registered to old RHN/Spacewalk
if ClassicCheck().is_registered_with_classic():
print(get_branding().REGISTERED_TO_OTHER_WARNING)
self._validate_options()
# gather installed products info
self.installed_mgr = inj.require(inj.INSTALLED_PRODUCTS_MANAGER)
previously_registered = False
if self.is_registered() and self.options.force:
previously_registered = True
# First let's try to un-register previous consumer; if this fails
# we'll let the error bubble up, so that we don't blindly re-register.
# managerlib.unregister handles the special case that the consumer has already been removed.
old_uuid = self.identity.uuid
print(
_("Unregistering from: {hostname}:{port}{prefix}").format(
hostname=conf["server"]["hostname"],
port=conf["server"]["port"],
prefix=conf["server"]["prefix"],
)
)
try:
unregister.UnregisterService(self.cp).unregister()
self.entitlement_dir.__init__()
self.product_dir.__init__()
log.info("--force specified, unregistered old consumer: {old_uuid}".format(old_uuid=old_uuid))
print(_("The system with UUID {old_uuid} has been unregistered").format(old_uuid=old_uuid))
except ssl.SSLError as e:
# since the user can override serverurl for register, a common use case is to try to switch servers
# using register --force... However, this normally cannot successfully unregister since the servers
# are different.
handle_exception("Unregister failed: {e}".format(e=e), e)
except Exception as e:
handle_exception("Unregister failed", e)
self.cp_provider.clean()
if previously_registered:
print(_("All local data removed"))
# Proceed with new registration:
try:
if self.options.token:
admin_cp = self.cp_provider.get_keycloak_auth_cp(self.options.token)
elif not self.options.activation_keys:
hostname = conf["server"]["hostname"]
if ":" in hostname:
normalized_hostname = "[{hostname}]".format(hostname=hostname)
else:
normalized_hostname = hostname
print(
_("Registering to: {hostname}:{port}{prefix}").format(
hostname=normalized_hostname,
port=conf["server"]["port"],
prefix=conf["server"]["prefix"],
)
)
self.cp_provider.set_user_pass(self.username, self.password)
admin_cp = self.cp_provider.get_basic_auth_cp()
else:
admin_cp = self.cp_provider.get_no_auth_cp()
# This is blocking and not async, which aside from blocking here, also
# means things like following name owner changes gets weird.
service = register.RegisterService(admin_cp)
if self.options.consumerid:
log.debug("Registering as existing consumer: {id}".format(id=self.options.consumerid))
consumer = service.register(None, consumerid=self.options.consumerid)
else:
if self.options.org:
owner_key = self.options.org
else:
owner_key = service.determine_owner_key(
username=self.username, get_owner_cb=self._get_owner_cb, no_owner_cb=self._no_owner_cb
)
environment_ids = self._process_environments(admin_cp, owner_key)
consumer = service.register(
owner_key,
activation_keys=self.options.activation_keys,
environments=environment_ids,
force=self.options.force,
name=self.options.consumername,
type=self.options.consumertype,
service_level=self.options.service_level,
)
except (connection.RestlibException, exceptions.ServiceError) as re:
log.exception(re)
mapped_message: str = ExceptionMapper().get_message(re)
system_exit(os.EX_SOFTWARE, mapped_message)
except Exception as e:
handle_exception(_("Error during registration: {e}").format(e=e), e)
else:
consumer_info = identity.ConsumerIdentity(consumer["idCert"]["key"], consumer["idCert"]["cert"])
print(_("The system has been registered with ID: {id}").format(id=consumer_info.getConsumerId()))
print(_("The registered system name is: {name}").format(name=consumer_info.getConsumerName()))
if self.options.service_level:
print(_("Service level set to: {level}").format(level=self.options.service_level))
# We have new credentials, restart virt-who
restart_virt_who()
# get a new UEP as the consumer
self.cp = self.cp_provider.get_consumer_auth_cp()
# log the version of the server we registered to
self.log_server_version()
facts = inj.require(inj.FACTS)
# FIXME: can these cases be replaced with invoking
# FactsLib (or a FactsManager?)
# Must update facts to clear out the old ones:
if self.options.consumerid:
log.debug("Updating facts")
#
# FIXME: Need a ConsumerFacts.sync or update or something
# TODO: We register, with facts, then update facts again...?
# Are we trying to sync potential new or dynamic facts?
facts.update_check(self.cp, consumer["uuid"], force=True)
# Facts and installed products went out with the registration request,
# manually write caches to disk:
# facts service job now(soon)
facts.write_cache()
self.installed_mgr.update_check(self.cp, consumer["uuid"])
if self.options.release:
# TODO: grab the list of valid options, and check
self.cp.updateConsumer(consumer["uuid"], release=self.options.release)
if self.autoattach:
self._do_auto_attach(consumer)
if (
self.options.consumerid
or self.options.activation_keys
or self.autoattach
or self.cp.has_capability(CONTENT_ACCESS_CERT_CAPABILITY)
):
log.debug("System registered, updating entitlements if needed")
# update certs, repos, and caches.
# FIXME: aside from the overhead, should this be cert_action_client.update?
self.entcertlib.update()
try:
profile_mgr = inj.require(inj.PROFILE_MANAGER)
# 767265: always force an upload of the packages when registering
profile_mgr.update_check(self.cp, consumer["uuid"], True)
except RemoteServerException as err:
# When it is not possible to upload profile ATM, then print only error about this
# to rhsm.log. The rhsmcertd will try to upload it next time.
log.error("Unable to upload profile: {err}".format(err=str(err)))
subscribed = 0
if self.options.activation_keys or self.autoattach:
# update with latest cert info
self.sorter = inj.require(inj.CERT_SORTER)
self.sorter.force_cert_check()
subscribed = show_autosubscribe_output(self.cp, self.identity)
self._request_validity_check()
return subscribed