def _register_consumer(self, name, facts, owner, env, callback):
"""
method run in the worker thread.
"""
try:
installed_mgr = InstalledProductsManager()
retval = self.backend.admin_uep.registerConsumer(
name=name,
facts=facts.get_facts(),
owner=owner,
environment=env,
installed_products=installed_mgr.format_for_server())
# Facts and installed products went out with the registration
# request, manually write caches to disk:
facts.write_cache()
installed_mgr.write_cache()
ProfileManager().update_check(self.backend.admin_uep,
retval['uuid'])
# We have new credentials, restart virt-who
restart_virt_who()
self.queue.put((callback, retval, None))
except Exception, e:
self.queue.put((callback, None, e))
def Unregister(self, proxy_options, locale, sender=None):
"""
Definition and implementation of D-Bus method
:param proxy_options: Definition of proxy settings
:param locale: String with locale (e.g. de_DE.UTF-8)
:param sender: Not used argument
"""
proxy_options = dbus_utils.dbus_to_python(proxy_options,
expected_type=dict)
locale = dbus_utils.dbus_to_python(locale, expected_type=str)
Locale.set(locale)
self.ensure_registered()
uep = self.build_uep(proxy_options, proxy_only=True)
try:
UnregisterService(uep).unregister()
except Exception as err:
raise dbus.DBusException(str(err))
# The system is unregistered now, restart virt-who to stop sending
# host-to-guest mapping.
restart_virt_who()
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 _do_command(self):
managerlib.clean_all_data(False)
print(_("All local data removed"))
self._request_validity_check()
# We have new credentials, restart virt-who
restart_virt_who()
def _register_consumer(self, name, facts, owner, env, activation_keys,
callback):
"""
method run in the worker thread.
"""
try:
installed_mgr = require(INSTALLED_PRODUCTS_MANAGER)
self.plugin_manager.run("pre_register_consumer",
name=name,
facts=facts.get_facts())
retval = self.backend.cp_provider.get_basic_auth_cp(
).registerConsumer(
name=name,
facts=facts.get_facts(),
owner=owner,
environment=env,
keys=activation_keys,
installed_products=installed_mgr.format_for_server())
self.plugin_manager.run("post_register_consumer",
consumer=retval,
facts=facts.get_facts())
# Facts and installed products went out with the registration
# request, manually write caches to disk:
facts.write_cache()
installed_mgr.write_cache()
cp = self.backend.cp_provider.get_basic_auth_cp()
# In practice, the only time this condition should be true is
# when we are working with activation keys. See BZ #888790.
if not self.backend.cp_provider.get_basic_auth_cp().username and \
not self.backend.cp_provider.get_basic_auth_cp().password:
# Write the identity cert to disk
managerlib.persist_consumer_cert(retval)
self.backend.update()
cp = self.backend.cp_provider.get_consumer_auth_cp()
# FIXME: this looks like we are updating package profile as
# basic auth
profile_mgr = require(PROFILE_MANAGER)
profile_mgr.update_check(cp, retval['uuid'])
# We have new credentials, restart virt-who
restart_virt_who()
self.queue.put((callback, retval, None))
except Exception:
self.queue.put((callback, None, sys.exc_info()))
def _register_consumer(self, name, facts, owner, env, activation_keys, callback):
"""
method run in the worker thread.
"""
try:
installed_mgr = require(INSTALLED_PRODUCTS_MANAGER)
self.plugin_manager.run("pre_register_consumer", name=name, facts=facts.get_facts())
retval = self.backend.cp_provider.get_basic_auth_cp().registerConsumer(
name=name,
facts=facts.get_facts(),
owner=owner,
environment=env,
keys=activation_keys,
installed_products=installed_mgr.format_for_server(),
)
self.plugin_manager.run("post_register_consumer", consumer=retval, facts=facts.get_facts())
# Facts and installed products went out with the registration
# request, manually write caches to disk:
facts.write_cache()
installed_mgr.write_cache()
cp = self.backend.cp_provider.get_basic_auth_cp()
# In practice, the only time this condition should be true is
# when we are working with activation keys. See BZ #888790.
if (
not self.backend.cp_provider.get_basic_auth_cp().username
and not self.backend.cp_provider.get_basic_auth_cp().password
):
# Write the identity cert to disk
managerlib.persist_consumer_cert(retval)
self.backend.update()
cp = self.backend.cp_provider.get_consumer_auth_cp()
# FIXME: this looks like we are updating package profile as
# basic auth
profile_mgr = require(PROFILE_MANAGER)
profile_mgr.update_check(cp, retval["uuid"])
# We have new credentials, restart virt-who
restart_virt_who()
self.queue.put((callback, retval, None))
except Exception:
self.queue.put((callback, None, sys.exc_info()))
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 _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 _register_consumer(self, name, facts, owner, env, callback):
"""
method run in the worker thread.
"""
try:
installed_mgr = InstalledProductsManager()
retval = self.backend.admin_uep.registerConsumer(name=name,
facts=facts.get_facts(), owner=owner, environment=env,
installed_products=installed_mgr.format_for_server())
# Facts and installed products went out with the registration
# request, manually write caches to disk:
facts.write_cache()
installed_mgr.write_cache()
ProfileManager().update_check(self.backend.admin_uep,
retval['uuid'])
# We have new credentials, restart virt-who
restart_virt_who()
self.queue.put((callback, retval, None))
except Exception, e:
self.queue.put((callback, None, e))
def Unregister(self, proxy_options, locale, sender=None):
"""
Definition and implementation of D-Bus method
:param proxy_options: Definition of proxy settings
:param locale: String with locale (e.g. de_DE.UTF-8)
:param sender: Not used argument
"""
proxy_options = dbus_utils.dbus_to_python(proxy_options, expected_type=dict)
locale = dbus_utils.dbus_to_python(locale, expected_type=str)
Locale.set(locale)
self.ensure_registered()
uep = self.build_uep(proxy_options, proxy_only=True)
try:
UnregisterService(uep).unregister()
except Exception as err:
raise dbus.DBusException(str(err))
# The system is unregistered now, restart virt-who to stop sending
# host-to-guest mapping.
restart_virt_who()
except Exception, 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 _unregister_item_clicked(self, widget):
log.info("Unregister button pressed, asking for confirmation.")
prompt = messageWindow.YesNoDialog(
_("<b>Are you sure you want to unregister?</b>"),
self._get_window())
prompt.connect('response', self._on_unregister_prompt_response)
def _proxy_config_item_clicked(self, widget):
self.network_config_dialog.set_parent_window(self._get_window())
self.network_config_dialog.show()
def _facts_item_clicked(self, widget):
try:
managerlib.unregister(self.backend.cp_provider.get_consumer_auth_cp(), self.identity.uuid)
except Exception, 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 _unregister_item_clicked(self, widget):
log.info("Unregister button pressed, asking for confirmation.")
prompt = messageWindow.YesNoDialog(
_("<b>Are you sure you want to unregister?</b>"),
self._get_window())
prompt.connect('response', self._on_unregister_prompt_response)
def _proxy_config_item_clicked(self, widget):
self.network_config_dialog.set_parent_window(self._get_window())
self.network_config_dialog.show()
def _facts_item_clicked(self, widget):
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
