def test_he_unicode(self): e = Exception("Ошибка при обновлении системных данных (см. /var/log/rhsm/rhsm.log") # e = FakeException(msg="Ошибка при обновлении системных данных (см. /var/log/rhsm/rhsm.log") try: handle_exception("a: %s" % e, e) except SystemExit as e: self.assertEqual(e.code, os.EX_SOFTWARE)
def _do_command(self): self._validate_options() supported_resources = get_supported_resources() if "environments" not in supported_resources: system_exit(os.EX_UNAVAILABLE, _("Error: Server does not support environments.")) try: if self.options.token: self.cp = self.cp_provider.get_keycloak_auth_cp( self.options.token) else: if not self.options.enabled: if self.options.username is None or self.options.password is None: print(_("This operation requires user credentials")) self.cp_provider.set_user_pass(self.username, self.password) self.cp = self.cp_provider.get_basic_auth_cp() self.identity = require(IDENTITY) if self.options.set: self._set_environments() else: self._list_environments() except connection.RestlibException as re: log.exception(re) log.error( "Error: Unable to retrieve environment list from server: {re}". format(re=re)) mapped_message: str = ExceptionMapper().get_message(re) system_exit(os.EX_SOFTWARE, mapped_message) except Exception as e: handle_exception( _("Error: Unable to retrieve environment list from server"), e)
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): self.assert_should_be_registered() try: # Also remove the content access mode cache to be sure we display # SCA or regular mode correctly content_access_mode = inj.require(inj.CONTENT_ACCESS_MODE_CACHE) if content_access_mode.exists(): content_access_mode.delete_cache() if self.options.force is True: # get current consumer identity consumer_identity = inj.require(inj.IDENTITY) # Force a regen of the entitlement certs for this consumer if not self.cp.regenEntitlementCertificates(consumer_identity.uuid, True): log.debug( "Warning: Unable to refresh entitlement certificates; service likely unavailable" ) self.entcertlib.update() log.debug("Refreshed local data") print(_("All local data refreshed")) except connection.RestlibException as re: log.error(re) mapped_message: str = ExceptionMapper().get_message(re) system_exit(os.EX_SOFTWARE, mapped_message) except Exception as e: handle_exception( _("Unable to perform refresh due to the following exception: {e}").format(e=e), e ) self._request_validity_check()
def test_he_restlib_exception_unicode(self): e = connection.RestlibException( 404, "Ошибка при обновлении системных данных (см. /var/log/rhsm/rhsm.log" ) try: handle_exception("обновлении", e) except SystemExit as e: self.assertEqual(e.code, os.EX_SOFTWARE)
def test_he_ssl_wrong_host(self): if not six.PY2: raise SkipTest( "M2Crypto-specific interface. Not used with Python 3.") e = SSL.Checker.WrongHost("expectedHost.example.com", "actualHost.example.com", "subjectAltName") try: handle_exception("huh", e) except SystemExit as e: self.assertEqual(e.code, os.EX_SOFTWARE)
def test_he_socket_error(self): # these error messages are bare strings, so we need to update the tests # if those messages change expected_msg = 'Network error, unable to connect to server. Please see /var/log/rhsm/rhsm.log for more information.' managercli.log.set_expected_msg(expected_msg) try: handle_exception(self.msg, socket.error()) except SystemExit as e: self.assertEqual(e.code, os.EX_SOFTWARE) self.assertEqual(managercli.log.expected_msg, expected_msg)
def _do_command(self): self._validate_options() try: # If we have a username/password, we're going to use that, otherwise # we'll use the identity certificate. We already know one or the other # exists: if self.options.token: self.cp = self.cp_provider.get_keycloak_auth_cp( self.options.token) elif self.options.username and self.options.password: self.cp_provider.set_user_pass(self.username, self.password) self.cp = self.cp_provider.get_basic_auth_cp() elif not self.is_registered() and self.options.show: pass else: # get an UEP as consumer self.cp = self.cp_provider.get_consumer_auth_cp() except connection.RestlibException as re: log.exception(re) log.error( "Error: Unable to retrieve service levels: {re}".format(re=re)) mapped_message: str = ExceptionMapper().get_message(re) system_exit(os.EX_SOFTWARE, mapped_message) except Exception as e: handle_exception(_("Error: Unable to retrieve service levels."), e) else: try: if self.options.unset: self.unset() elif self.options.set is not None: self.set() elif self.options.list: self.list_service_levels() elif self.options.show: self.show() else: self.show() except UnauthorizedException as uex: handle_exception(_(str(uex)), uex) except connection.GoneException as ge: raise ge except connection.RestlibException as re_err: log.exception(re_err) log.error( "Error: Unable to retrieve service levels: {err}".format( err=re_err)) mapped_message: str = ExceptionMapper().get_message(re_err) system_exit(os.EX_SOFTWARE, mapped_message) except ProxyException: system_exit( os.EX_UNAVAILABLE, _("Proxy connection failed, please check your settings."), )
def _do_command(self): try: # get a UEP if self.options.token: self.cp = self.cp_provider.get_keycloak_auth_cp( self.options.token) else: self.cp_provider.set_user_pass(self.username, self.password) self.cp = self.cp_provider.get_basic_auth_cp() owners = self.cp.getOwnerList(self.username) log.debug("Successfully retrieved org list from server.") if len(owners): print("+-------------------------------------------+") print(" {name} {label}".format( name=self.username, label=_("Organizations"))) print("+-------------------------------------------+") print("") for owner in owners: print( columnize(ORG_LIST, echo_columnize_callback, owner["displayName"], owner["key"]) + "\n") else: print( _("{username} cannot register with any organizations."). format(username=self.username)) except connection.RestlibException as re: log.exception(re) log.error( "Error: Unable to retrieve org list from server: {re}".format( re=re)) mapped_message: str = ExceptionMapper().get_message(re) system_exit(os.EX_SOFTWARE, mapped_message) except Exception as e: handle_exception( _("Error: Unable to retrieve org list from server"), e)
def _do_command(self): self._validate_options() try: if self.options.token: self.cp = self.cp_provider.get_keycloak_auth_cp( self.options.token) else: self.cp_provider.set_user_pass(self.username, self.password) self.cp = self.cp_provider.get_basic_auth_cp() supported_resources = get_supported_resources() if 'environments' in supported_resources: environments = self._get_environments(self.org) if len(environments): print("+-------------------------------------------+") print(" {env}".format(env=_('Environments'))) print("+-------------------------------------------+") for env in environments: print( columnize(ENVIRONMENT_LIST, echo_columnize_callback, env['name'], env['description'] or "") + "\n") else: print(_("This org does not have any environments.")) else: system_exit(os.EX_UNAVAILABLE, _("Error: Server does not support environments.")) log.debug("Successfully retrieved environment list from server.") except connection.RestlibException as re: log.exception(re) log.error( "Error: Unable to retrieve environment list from server: {re}". format(re=re)) system_exit(os.EX_SOFTWARE, str(re)) except Exception as e: handle_exception( _("Error: Unable to retrieve environment list from server"), e)
def _do_command(self): """ Executes the command. """ self.assert_should_be_registered() self._validate_options() try: # FIXME: why just facts and package profile update here? # update facts first, if we need to facts = inj.require(inj.FACTS) facts.update_check(self.cp, self.identity.uuid) profile_mgr = inj.require(inj.PROFILE_MANAGER) profile_mgr.update_check(self.cp, self.identity.uuid) # BZ 1248833 Ensure we print out the display message if we get any back response = self.cp.activateMachine(self.identity.uuid, self.options.email, self.options.locale) if response and response.get('displayMessage'): system_exit(0, response.get('displayMessage')) except connection.GoneException as ge: raise ge except connection.RestlibException as e: # candlepin throws an exception during activateMachine, even for # 200's. We need to look at the code in the RestlibException and proceed # accordingly if 200 <= e.code <= 210: system_exit(0, e) else: handle_exception(u"Unable to redeem: {e}".format(e=e), e) except Exception as e: handle_exception(u"Unable to redeem: {e}".format(e=e), e) self._request_validity_check()
def test_he_ssl_error(self): e = ssl.SSLError() try: handle_exception("huh", e) except SystemExit as e: self.assertEqual(e.code, os.EX_SOFTWARE)
def test_he_network_exception(self): e = connection.NetworkException(1337) try: handle_exception("huh", e) except SystemExit as e: self.assertEqual(e.code, os.EX_SOFTWARE)
def test_he_remote_server_exception(self): e = connection.RemoteServerException(1984) try: handle_exception("huh", e) except SystemExit as e: self.assertEqual(e.code, os.EX_SOFTWARE)
def test_he_bad_certificate(self): e = connection.BadCertificateException("/road/to/nowhwere") try: handle_exception("huh", e) except SystemExit as e: self.assertEqual(e.code, os.EX_SOFTWARE)
def test_he_restlib_exception(self): e = connection.RestlibException(404, "this is a msg") try: handle_exception("huh", e) except SystemExit as e: self.assertEqual(e.code, os.EX_SOFTWARE)
except KeyboardInterrupt: system_exit(0, "\nUser interrupted process.") except ImportError as err: system_exit( 2, "Unable to find Subscription Manager module.\n" "Error: %s" % err) def main(): # execute try: return migrate.main() except KeyboardInterrupt: system_exit(0, "\nUser interrupted process.") return 0 if __name__ == '__main__': try: sys.exit(abs(main() or 0)) except SystemExit as sys_err: # this is a non-exceptional exception thrown by Python 2.4, just # re-raise, bypassing handle_exception raise sys_err except KeyboardInterrupt: system_exit(0, "\nUser interrupted process.") except Exception as err: handle_exception("Exception caught in rhm-migrate-classic-to-rhsm", err)
def test_he(self): e = FakeException() try: handle_exception(self.msg, e) except SystemExit as e: self.assertEqual(e.code, os.EX_SOFTWARE)
from subscription_manager.cli_command.cli import handle_exception except KeyboardInterrupt: system_exit(0, "\nUser interrupted process.") except ImportError as err: system_exit(2, "Unable to find Subscription Manager module.\nError:", str(err)) def main(): # execute try: return migrate.main(five_to_six_script=True) except KeyboardInterrupt: system_exit(0, "\nUser interrupted process.") return 0 if __name__ == '__main__': try: sys.exit(abs(main() or 0)) except SystemExit as e: # this is a non-exceptional exception thrown by Python 2.4, just # re-raise, bypassing handle_exception raise e except KeyboardInterrupt: system_exit(0, "\nUser interrupted process.") except Exception as e: handle_exception("Exception caught in sat5to6", e)
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
ga_loader.init_ga() except KeyboardInterrupt: system_exit(0, "\nUser interrupted process.") except ImportError as err: system_exit(2, "Unable to find Subscription Manager module.\n" "Error: %s" % err) def main(): # execute try: return managercli.ManagerCLI().main() except KeyboardInterrupt: system_exit(0, "\nUser interrupted process.") return 0 if __name__ == '__main__': try: sys.exit(abs(main() or 0)) except SystemExit as err: # This is a non-exceptional exception thrown by Python 2.4, just # re-raise, bypassing handle_exception raise err except KeyboardInterrupt: system_exit(0, "\nUser interrupted process.") except Exception as e: handle_exception("exception caught in subscription-manager", e)
def _do_command(self): self.options.destination = os.path.expanduser(self.options.destination) self._validate_options() consumer = inj.require(inj.IDENTITY) if not consumer.is_valid(): system_exit(ERR_NOT_REGISTERED_CODE, ERR_NOT_REGISTERED_MSG) code = self._make_code() archive_name = "rhsm-debug-system-%s" % code tar_file_name = "%s.tar.gz" % archive_name # /var/spool/rhsm/debug/rhsm-debug-system-20131212-121234/ content_path = os.path.join(self.assemble_path, archive_name) # /var/spool/rhsm/debug/rhsm-debug-system-20131212-123413.tar.gz tar_file_path = os.path.join(self.assemble_path, tar_file_name) try: # assemble path is in the package, so should always exist self._makedir(content_path) owner = self.cp.getOwner(consumer.uuid) self._write_flat_file(content_path, "consumer.json", self.cp.getConsumer(consumer.uuid)) self._write_flat_file(content_path, "compliance.json", self.cp.getCompliance(consumer.uuid)) self._write_flat_file(content_path, "entitlements.json", self.cp.getEntitlementList(consumer.uuid)) self._write_flat_file( content_path, "pools.json", self.cp.getPoolsList(consumer.uuid, True, None, owner["key"])) self._write_flat_file(content_path, "version.json", self._get_version_info()) # FIXME: we need to anon proxy passwords? sos = self.options.sos defaults = conf.defaults() # sosreport collects /etc/rhsm/* and /var/*/rhsm/*, so these would # be redundant for sos if not sos: # copy rhsm.conf specifically self._copy_cert_directory("/etc/rhsm", content_path) self._copy_directory("/var/log/rhsm", content_path) self._copy_directory("/var/lib/rhsm", content_path) if not sos: self._copy_cert_directory(DEFAULT_PRODUCT_CERT_DIR, content_path) if defaults["productcertdir"] != conf["rhsm"][ "productCertDir"] or not sos: self._copy_cert_directory(conf["rhsm"]["productCertDir"], content_path) if defaults["entitlementcertdir"] != conf["rhsm"][ "entitlementCertDir"] or not sos: self._copy_cert_directory(conf["rhsm"]["entitlementCertDir"], content_path) if defaults["consumercertdir"] != conf["rhsm"][ "consumerCertDir"] or not sos: self._copy_cert_directory(conf["rhsm"]["consumerCertDir"], content_path) # If ca_cert_dir and pluginconfdif are configured as subdirs of /etc/rhsm # (as is the default) we will have already copied there contents, # so ignore directory exists errors try: if defaults["ca_cert_dir"] != conf["rhsm"][ "ca_cert_dir"] or not sos: self._copy_cert_directory(conf["rhsm"]["ca_cert_dir"], content_path) except EnvironmentError as e: if e.errno != errno.EEXIST: raise try: if defaults["pluginconfdir"] != conf["rhsm"][ "pluginconfdir"] or not sos: self._copy_directory(conf["rhsm"]["pluginconfdir"], content_path) except EnvironmentError as e: if e.errno != errno.EEXIST: raise # build an archive by default if self.options.archive: try: tf = tarfile.open(tar_file_path, "w:gz") tf.add(content_path, archive_name) finally: tf.close() final_path = os.path.join(self.options.destination, "rhsm-debug-system-%s.tar.gz" % code) self.final_destination_path = final_path sfm = SaferFileMove() sfm.move(tar_file_path, final_path) print(_("Wrote: {final_path}").format(final_path=final_path)) else: # NOTE: this will fail across filesystems. We could add a force # flag to for creation of a specific name with approriate # warnings. dest_dir_name = os.path.join(self.options.destination, archive_name) # create the dest dir, and set it's perms, this is atomic ish self._makedir(dest_dir_name) # try to rename the dir atomically # rename only works on the same filesystem, but it is atomic. os.rename(content_path, dest_dir_name) print( _("Wrote: {destination_dir_name}").format( destination_dir_name=dest_dir_name)) except Exception as e: handle_exception( _("Unable to create zip file of system information: {error}"). format(error=e), e) sys.exit(os.EX_SOFTWARE) finally: if content_path and os.path.isdir(content_path): shutil.rmtree(content_path, True)
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
def _do_command(self): # get current consumer identity identity = inj.require(inj.IDENTITY) # check for Classic before doing anything else if ClassicCheck().is_registered_with_classic(): if identity.is_valid(): print( _("server type: {type}").format( type=get_branding().REGISTERED_TO_BOTH_SUMMARY)) else: # no need to continue if user is only registered to Classic print( _("server type: {type}").format( type=get_branding().REGISTERED_TO_OTHER_SUMMARY)) return try: self._validate_options() consumerid = self.identity.uuid consumer_name = self.identity.name if not self.options.regenerate: owner = get_current_owner(self.cp, self.identity) ownername = owner['displayName'] ownerid = owner['key'] print( _('system identity: {consumerid}').format( consumerid=consumerid)) print( _('name: {consumer_name}').format( consumer_name=consumer_name)) print(_('org name: {ownername}').format(ownername=ownername)) print(_('org ID: {ownerid}').format(ownerid=ownerid)) supported_resources = get_supported_resources( self.cp, self.identity) if 'environments' in supported_resources: consumer = self.cp.getConsumer(consumerid) environment = consumer['environment'] if environment: environment_name = environment['name'] else: environment_name = _("None") print( _('environment name: {environment_name}').format( environment_name=environment_name)) else: if self.options.force: # get an UEP with basic auth or keycloak auth if self.options.token: self.cp = self.cp_provider.get_keycloak_auth_cp( self.options.token) else: self.cp_provider.set_user_pass(self.username, self.password) self.cp = self.cp_provider.get_basic_auth_cp() consumer = self.cp.regenIdCertificate(consumerid) managerlib.persist_consumer_cert(consumer) # do this in persist_consumer_cert? or some other # high level, "I just registered" thing self.identity.reload() print(_("Identity certificate has been regenerated.")) log.debug("Successfully generated a new identity from server.") except connection.GoneException as ge: # Gone exception is caught in CliCommand and a consistent message # is printed there for all commands raise ge except connection.RestlibException as re: log.exception(re) log.error( u"Error: Unable to generate a new identity for the system: {re}" ).format(re=re) system_exit(os.EX_SOFTWARE, str(re)) except Exception as e: handle_exception( _("Error: Unable to generate a new identity for the system"), e)
def _do_command(self): """ Executes the command. """ self._validate_options() return_code = 0 if self.is_registered(): ent_service = entitlement.EntitlementService(self.cp) try: if self.options.all: total = ent_service.remove_all_entitlements() # total will be None on older Candlepins that don't # support returning the number of subscriptions unsubscribed from if total is None: print(_("All subscriptions have been removed at the server.")) else: count = total["deletedRecords"] print( ungettext( "%s subscription removed at the server.", "%s subscriptions removed at the server.", count, ) % count ) else: # Try to remove subscriptions defined by pool IDs first (remove --pool=...) if self.options.pool_ids: ( removed_pools, unremoved_pools, removed_serials, ) = ent_service.remove_entilements_by_pool_ids(self.options.pool_ids) if not removed_pools: return_code = 1 self._print_unbind_ids_result(removed_pools, unremoved_pools, "pools") else: removed_serials = [] # Then try to remove subscriptions defined by serials (remove --serial=...) unremoved_serials = [] if self.options.serials: serials = unique_list_items(self.options.serials) # Don't remove serials already removed by a pool serials_to_remove = [serial for serial in serials if serial not in removed_serials] _removed_serials, unremoved_serials = ent_service.remove_entitlements_by_serials( serials_to_remove ) removed_serials.extend(_removed_serials) if not _removed_serials: return_code = 1 # Print final result of removing pools self._print_unbind_ids_result(removed_serials, unremoved_serials, "serial numbers") except connection.GoneException as ge: raise ge except connection.RestlibException as err: log.error(err) mapped_message: str = ExceptionMapper().get_message(err) system_exit(os.EX_SOFTWARE, mapped_message) except Exception as e: handle_exception( _("Unable to perform remove due to the following exception: {e}").format(e=e), e ) else: # We never got registered, just remove the cert try: if self.options.all: total = 0 for ent in self.entitlement_dir.list(): ent.delete() total = total + 1 print(_("{total} subscriptions removed from this system.").format(total=total)) else: if self.options.serials or self.options.pool_ids: serials = self.options.serials or [] pool_ids = self.options.pool_ids or [] count = 0 for ent in self.entitlement_dir.list(): ent_pool_id = str(getattr(ent.pool, "id", None) or "") if str(ent.serial) in serials or ent_pool_id in pool_ids: ent.delete() print( _( "Subscription with serial number {serial} removed from this system" ).format(serial=str(ent.serial)) ) count = count + 1 if count == 0: return_code = 1 except Exception as e: handle_exception( _("Unable to perform remove due to the following exception: {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