name : cc_rh_subscription.py # Copyright (C) 2015 Red Hat, Inc. # # Author: Brent Baude <bbaude@redhat.com> # # This file is part of cloud-init. See LICENSE file for license information. """Red Hat Subscription: Register Red Hat Enterprise Linux based system""" import logging from textwrap import dedent from cloudinit import subp, util from cloudinit.cloud import Cloud from cloudinit.config import Config from cloudinit.config.schema import MetaSchema, get_meta_doc from cloudinit.settings import PER_INSTANCE LOG = logging.getLogger(__name__) MODULE_DESCRIPTION = """\ Register a Red Hat system either by username and password *or* activation and org. Following a successful registration, you can: - auto-attach subscriptions - set the service level - add subscriptions based on pool id - enable/disable yum repositories based on repo id - alter the rhsm_baseurl and server-hostname in ``/etc/rhsm/rhs.conf``. """ meta: MetaSchema = { "id": "cc_rh_subscription", "name": "Red Hat Subscription", "title": "Register Red Hat Enterprise Linux based system", "description": MODULE_DESCRIPTION, "distros": ["fedora", "rhel", "openeuler"], "frequency": PER_INSTANCE, "examples": [ dedent( """\ rh_subscription: username: joe@foo.bar ## Quote your password if it has symbols to be safe password: '1234abcd' """ ), dedent( """\ rh_subscription: activation-key: foobar org: 12345 """ ), dedent( """\ rh_subscription: activation-key: foobar org: 12345 auto-attach: true service-level: self-support add-pool: - 1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a - 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b enable-repo: - repo-id-to-enable - other-repo-id-to-enable disable-repo: - repo-id-to-disable - other-repo-id-to-disable # Alter the baseurl in /etc/rhsm/rhsm.conf rhsm-baseurl: http://url # Alter the server hostname in /etc/rhsm/rhsm.conf server-hostname: foo.bar.com """ ), ], "activate_by_schema_keys": ["rh_subscription"], } __doc__ = get_meta_doc(meta) def handle(name: str, cfg: Config, cloud: Cloud, args: list) -> None: sm = SubscriptionManager(cfg, log=LOG) if not sm.is_configured(): LOG.debug("%s: module not configured.", name) return None if not sm.is_registered(): try: verify, verify_msg = sm._verify_keys() if verify is not True: raise SubscriptionError(verify_msg) cont = sm.rhn_register() if not cont: raise SubscriptionError( "Registration failed or did not run completely" ) # Splitting up the registration, auto-attach, and servicelevel # commands because the error codes, messages from subman are not # specific enough. # Attempt to change the service level if sm.auto_attach and sm.servicelevel is not None: if not sm._set_service_level(): raise SubscriptionError("Setting of service-level failed") else: sm.log.debug("Completed auto-attach with service level") elif sm.auto_attach: if not sm._set_auto_attach(): raise SubscriptionError("Setting auto-attach failed") else: sm.log.debug("Completed auto-attach") if sm.pools is not None: if not isinstance(sm.pools, list): pool_fail = "Pools must in the format of a list" raise SubscriptionError(pool_fail) return_stat = sm.addPool(sm.pools) if not return_stat: raise SubscriptionError( "Unable to attach pools {0}".format(sm.pools) ) return_stat = sm.update_repos() if not return_stat: raise SubscriptionError("Unable to add or remove repos") sm.log_success("rh_subscription plugin completed successfully") except SubscriptionError as e: sm.log_warn(str(e)) sm.log_warn("rh_subscription plugin did not complete successfully") else: sm.log_success("System is already registered") class SubscriptionError(Exception): pass class SubscriptionManager: valid_rh_keys = [ "org", "activation-key", "username", "password", "disable-repo", "enable-repo", "add-pool", "rhsm-baseurl", "server-hostname", "auto-attach", "service-level", ] def __init__(self, cfg, log=None): if log is None: log = LOG self.log = log self.cfg = cfg self.rhel_cfg = self.cfg.get("rh_subscription", {}) self.rhsm_baseurl = self.rhel_cfg.get("rhsm-baseurl") self.server_hostname = self.rhel_cfg.get("server-hostname") self.pools = self.rhel_cfg.get("add-pool") self.activation_key = self.rhel_cfg.get("activation-key") self.org = self.rhel_cfg.get("org") self.userid = self.rhel_cfg.get("username") self.password = self.rhel_cfg.get("password") self.auto_attach = self.rhel_cfg.get("auto-attach") self.enable_repo = self.rhel_cfg.get("enable-repo") self.disable_repo = self.rhel_cfg.get("disable-repo") self.servicelevel = self.rhel_cfg.get("service-level") def log_success(self, msg): """Simple wrapper for logging info messages. Useful for unittests""" self.log.info(msg) def log_warn(self, msg): """Simple wrapper for logging warning messages. Useful for unittests""" self.log.warning(msg) def _verify_keys(self): """ Checks that the keys in the rh_subscription dict from the user-data are what we expect. """ for k in self.rhel_cfg: if k not in self.valid_rh_keys: bad_key = ( "{0} is not a valid key for rh_subscription. " "Valid keys are: " "{1}".format(k, ", ".join(self.valid_rh_keys)) ) return False, bad_key # Check for bad auto-attach value if (self.auto_attach is not None) and not ( util.is_true(self.auto_attach) or util.is_false(self.auto_attach) ): not_bool = ( "The key auto-attach must be a boolean value (True/False " ) return False, not_bool if (self.servicelevel is not None) and ( (not self.auto_attach) or (util.is_false(str(self.auto_attach))) ): no_auto = ( "The service-level key must be used in conjunction " "with the auto-attach key. Please re-run with " "auto-attach: True" ) return False, no_auto return True, None def is_registered(self): """ Checks if the system is already registered and returns True if so, else False """ cmd = ["identity"] try: _sub_man_cli(cmd) except subp.ProcessExecutionError: return False return True def rhn_register(self): """ Registers the system by userid and password or activation key and org. Returns True when successful False when not. """ if (self.activation_key is not None) and (self.org is not None): # register by activation key cmd = [ "register", "--activationkey={0}".format(self.activation_key), "--org={0}".format(self.org), ] # If the baseurl and/or server url are passed in, we register # with them. if self.rhsm_baseurl is not None: cmd.append("--baseurl={0}".format(self.rhsm_baseurl)) if self.server_hostname is not None: cmd.append("--serverurl={0}".format(self.server_hostname)) try: return_out = _sub_man_cli(cmd, logstring_val=True)[0] except subp.ProcessExecutionError as e: if e.stdout == "": self.log_warn( "Registration failed due to: {0}".format(e.stderr) ) return False elif (self.userid is not None) and (self.password is not None): # register by username and password cmd = [ "register", "--username={0}".format(self.userid), "--password={0}".format(self.password), ] # If the baseurl and/or server url are passed in, we register # with them. if self.rhsm_baseurl is not None: cmd.append("--baseurl={0}".format(self.rhsm_baseurl)) if self.server_hostname is not None: cmd.append("--serverurl={0}".format(self.server_hostname)) # Attempting to register the system only try: return_out = _sub_man_cli(cmd, logstring_val=True)[0] except subp.ProcessExecutionError as e: if e.stdout == "": self.log_warn( "Registration failed due to: {0}".format(e.stderr) ) return False else: self.log_warn( "Unable to register system due to incomplete information." ) self.log_warn( "Use either activationkey and org *or* userid and password" ) return False reg_id = return_out.split("ID: ")[1].rstrip() self.log.debug("Registered successfully with ID %s", reg_id) return True def _set_service_level(self): cmd = [ "attach", "--auto", "--servicelevel={0}".format(self.servicelevel), ] try: return_out = _sub_man_cli(cmd)[0] except subp.ProcessExecutionError as e: if e.stdout.rstrip() != "": for line in e.stdout.split("\n"): if line != "": self.log_warn(line) else: self.log_warn( "Setting the service level failed with: {0}".format( e.stderr.strip() ) ) return False for line in return_out.split("\n"): if line != "": self.log.debug(line) return True def _set_auto_attach(self): cmd = ["attach", "--auto"] try: return_out = _sub_man_cli(cmd)[0] except subp.ProcessExecutionError as e: self.log_warn("Auto-attach failed with: {0}".format(e)) return False for line in return_out.split("\n"): if line != "": self.log.debug(line) return True def _getPools(self): """ Gets the list pools for the active subscription and returns them in list form. """ available = [] consumed = [] # Get all available pools cmd = ["list", "--available", "--pool-only"] results = _sub_man_cli(cmd)[0] available = (results.rstrip()).split("\n") # Get all consumed pools cmd = ["list", "--consumed", "--pool-only"] results = _sub_man_cli(cmd)[0] consumed = (results.rstrip()).split("\n") return available, consumed def _getRepos(self): """ Obtains the current list of active yum repositories and returns them in list form. """ cmd = ["repos", "--list-enabled"] return_out = _sub_man_cli(cmd)[0] active_repos = [] for repo in return_out.split("\n"): if "Repo ID:" in repo: active_repos.append((repo.split(":")[1]).strip()) cmd = ["repos", "--list-disabled"] return_out = _sub_man_cli(cmd)[0] inactive_repos = [] for repo in return_out.split("\n"): if "Repo ID:" in repo: inactive_repos.append((repo.split(":")[1]).strip()) return active_repos, inactive_repos def addPool(self, pools): """ Takes a list of subscription pools and "attaches" them to the current subscription """ # An empty list was passed if len(pools) == 0: self.log.debug("No pools to attach") return True pool_available, pool_consumed = self._getPools() pool_list = [] cmd = ["attach"] for pool in pools: if (pool not in pool_consumed) and (pool in pool_available): pool_list.append("--pool={0}".format(pool)) else: self.log_warn("Pool {0} is not available".format(pool)) if len(pool_list) > 0: cmd.extend(pool_list) try: _sub_man_cli(cmd) self.log.debug( "Attached the following pools to your system: %s", (", ".join(pool_list)).replace("--pool=", ""), ) return True except subp.ProcessExecutionError as e: self.log_warn( "Unable to attach pool {0} due to {1}".format(pool, e) ) return False def update_repos(self): """ Takes a list of yum repo ids that need to be disabled or enabled; then it verifies if they are already enabled or disabled and finally executes the action to disable or enable """ erepos = self.enable_repo drepos = self.disable_repo if erepos is None: erepos = [] if drepos is None: drepos = [] if not isinstance(erepos, list): self.log_warn("Repo IDs must in the format of a list.") return False if not isinstance(drepos, list): self.log_warn("Repo IDs must in the format of a list.") return False # Bail if both lists are not populated if (len(erepos) == 0) and (len(drepos) == 0): self.log.debug("No repo IDs to enable or disable") return True active_repos, inactive_repos = self._getRepos() # Creating a list of repoids to be enabled enable_list = [] enable_list_fail = [] for repoid in erepos: if repoid in inactive_repos: enable_list.append("--enable={0}".format(repoid)) else: enable_list_fail.append(repoid) # Creating a list of repoids to be disabled disable_list = [] disable_list_fail = [] for repoid in drepos: if repoid in active_repos: disable_list.append("--disable={0}".format(repoid)) else: disable_list_fail.append(repoid) # Logging any repos that are already enabled or disabled if len(enable_list_fail) > 0: for fail in enable_list_fail: # Check if the repo exists or not if fail in active_repos: self.log.debug("Repo %s is already enabled", fail) else: self.log_warn( "Repo {0} does not appear to exist".format(fail) ) if len(disable_list_fail) > 0: for fail in disable_list_fail: self.log.debug( "Repo %s not disabled because it is not enabled", fail ) cmd = ["repos"] if len(disable_list) > 0: cmd.extend(disable_list) if len(enable_list) > 0: cmd.extend(enable_list) try: _sub_man_cli(cmd) except subp.ProcessExecutionError as e: self.log_warn("Unable to alter repos due to {0}".format(e)) return False if len(enable_list) > 0: self.log.debug( "Enabled the following repos: %s", (", ".join(enable_list)).replace("--enable=", ""), ) if len(disable_list) > 0: self.log.debug( "Disabled the following repos: %s", (", ".join(disable_list)).replace("--disable=", ""), ) return True def is_configured(self): return bool((self.userid and self.password) or self.activation_key) def _sub_man_cli(cmd, logstring_val=False): """ Uses the preferred cloud-init subprocess def of subp.subp and runs subscription-manager. Breaking this to a separate function for later use in mocking and unittests """ return subp.subp(["subscription-manager"] + cmd, logstring=logstring_val)