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