def validate_options(self, options): if not set(['installed', 'consumed', 'available']).issuperset( options['pool_subsets']): raise exceptions.ValidationError( _('Error: invalid listing type provided. Only "installed", ' '"consumed", or "available" are allowed')) if options['show_all'] and 'available' not in options['pool_subsets']: raise exceptions.ValidationError( _("Error: --all is only applicable with --available")) elif options['on_date'] and 'available' not in options['pool_subsets']: raise exceptions.ValidationError( _("Error: --ondate is only applicable with --available")) elif options['service_level'] is not None \ and not set(['consumed', 'available']).intersection(options['pool_subsets']): raise exceptions.ValidationError( _("Error: --servicelevel is only applicable with --available or --consumed" )) elif options['match_installed'] and 'available' not in options[ 'pool_subsets']: raise exceptions.ValidationError( _("Error: --match-installed is only applicable with --available" )) elif options['no_overlap'] and 'available' not in options[ 'pool_subsets']: raise exceptions.ValidationError( _("Error: --no-overlap is only applicable with --available")) elif options['pool_only'] \ and not set(['consumed', 'available']).intersection(options['pool_subsets']): raise exceptions.ValidationError( _("Error: --pool-only is only applicable with --available and/or --consumed" )) elif not self.identity.is_valid( ) and 'available' in options['pool_subsets']: raise exceptions.ValidationError( _("Error: this system is not registered"))
def validate_options(self, options): if self.identity.is_valid() and options['force'] is not True: raise exceptions.ValidationError(_("This system is already registered. Add force to options to " "override.")) elif options.get('name') == '': raise exceptions.ValidationError(_("Error: system name can not be empty.")) elif options['consumerid'] and options['force'] is True: raise exceptions.ValidationError(_("Error: Can not force registration while attempting to " "recover registration with consumerid. Please use --force without --consumerid to re-register" " or use the clean command and try again without --force.")) # If 'activation_keys' already exists in the dictionary, leave it. Otherwise, set to None. if options['activation_keys']: # 746259: Don't allow the user to pass in an empty string as an activation key if '' == options['activation_keys']: raise exceptions.ValidationError(_("Error: Must specify an activation key")) elif getattr(self.cp, 'username', None) or getattr(self.cp, 'password', None): raise exceptions.ValidationError(_("Error: Activation keys do not require user credentials.")) elif options['consumerid']: raise exceptions.ValidationError(_("Error: Activation keys can not be used with previously" " registered IDs.")) elif options['environment']: raise exceptions.ValidationError(_("Error: Activation keys do not allow environments to be" " specified.")) elif not getattr(self.cp, 'username', None) or not getattr(self.cp, 'password', None): raise exceptions.ValidationError(_("Error: Missing username or password."))
def validate_options(self, options): if not set(["installed", "consumed", "available"]).issuperset( options["pool_subsets"]): raise exceptions.ValidationError( _('Error: invalid listing type provided. Only "installed", ' '"consumed", or "available" are allowed')) if options["show_all"] and "available" not in options["pool_subsets"]: raise exceptions.ValidationError( _("Error: --all is only applicable with --available")) elif options["on_date"] and "available" not in options["pool_subsets"]: raise exceptions.ValidationError( _("Error: --ondate is only applicable with --available")) elif options["service_level"] is not None and not set( ["consumed", "available"]).intersection(options["pool_subsets"]): raise exceptions.ValidationError( _("Error: --servicelevel is only applicable with --available or --consumed" )) elif options["match_installed"] and "available" not in options[ "pool_subsets"]: raise exceptions.ValidationError( _("Error: --match-installed is only applicable with --available" )) elif options["no_overlap"] and "available" not in options[ "pool_subsets"]: raise exceptions.ValidationError( _("Error: --no-overlap is only applicable with --available")) elif options["pool_only"] and not set( ["consumed", "available"]).intersection(options["pool_subsets"]): raise exceptions.ValidationError( _("Error: --pool-only is only applicable with --available and/or --consumed" )) elif not self.identity.is_valid( ) and "available" in options["pool_subsets"]: raise exceptions.ValidationError( _("Error: this system is not registered"))
def get_pools(self, pool_subsets=None, matches=None, pool_only=None, match_installed=None, no_overlap=None, service_level=None, show_all=None, on_date=None, future=None, after=None, **kwargs): # We accept a **kwargs argument so that the DBus object can pass whatever dictionary it receives # via keyword expansion. if kwargs: raise exceptions.ValidationError(_("Unknown arguments: %s") % kwargs.keys()) if isinstance(pool_subsets, six.string_types): pool_subsets = [pool_subsets] # [] or None means look at all pools if not pool_subsets: pool_subsets = ['installed', 'consumed', 'available'] options = { 'pool_subsets': pool_subsets, 'matches': matches, 'pool_only': pool_only, 'match_installed': match_installed, 'no_overlap': no_overlap, 'service_level': service_level, 'show_all': show_all, 'on_date': on_date, 'future': future, 'after': after, } self.validate_options(options) results = {} if 'installed' in pool_subsets: installed = products.InstalledProducts(self.cp).list(matches) results['installed'] = [x._asdict() for x in installed] if 'consumed' in pool_subsets: consumed = self.get_consumed_product_pools(service_level=service_level, matches=matches) if pool_only: results['consumed'] = [x._asdict()['pool_id'] for x in consumed] else: results['consumed'] = [x._asdict() for x in consumed] if 'available' in pool_subsets: available = self.get_available_pools( show_all=show_all, on_date=on_date, no_overlap=no_overlap, match_installed=match_installed, matches=matches, service_level=service_level, future=future, after=after, ) if pool_only: results['available'] = [x['id'] for x in available] else: results['available'] = available return results
def register(self, org, activation_keys=None, environment=None, force=None, name=None, consumerid=None, type=None, role=None, addons=None, service_level=None, usage=None, **kwargs): # We accept a kwargs argument so that the DBus object can pass the options dictionary it # receives transparently to the service via dictionary unpacking. This strategy allows the # DBus object to be more independent of the service implementation. # If there are any values in kwargs that don't map to keyword arguments defined in the message # signature we want to consider that an error. if kwargs: raise exceptions.ValidationError(_("Unknown arguments: %s") % kwargs.keys()) syspurpose = syspurposelib.read_syspurpose() role = role or syspurpose.get('role', '') addons = addons or syspurpose.get('addons', []) usage = usage or syspurpose.get('usage', '') service_level = service_level or syspurpose.get('service_level_agreement', '') type = type or "system" options = { 'activation_keys': activation_keys, 'environment': environment, 'force': force, 'name': name, 'consumerid': consumerid, 'type': type } self.validate_options(options) environment = options['environment'] facts_dict = self.facts.get_facts() # Default to the hostname if no name is given consumer_name = options['name'] or socket.gethostname() self.plugin_manager.run("pre_register_consumer", name=consumer_name, facts=facts_dict) if consumerid: consumer = self.cp.getConsumer(consumerid) if consumer.get('type', {}).get('manifest', {}): raise exceptions.ServiceError( "Registration attempted with a consumer ID that is not of type 'system'") else: consumer = self.cp.registerConsumer( name=consumer_name, facts=facts_dict, owner=org, environment=environment, keys=options.get('activation_keys'), installed_products=self.installed_mgr.format_for_server(), content_tags=self.installed_mgr.tags, type=type, role=role, addons=addons, service_level=service_level, usage=usage ) self.installed_mgr.write_cache() self.plugin_manager.run("post_register_consumer", consumer=consumer, facts=facts_dict) managerlib.persist_consumer_cert(consumer) # Now that we are registered, load the new identity self.identity.reload() # We want a new SyncedStore every time as we otherwise can hold onto bad state in # long-lived services in dbus uep = inj.require(inj.CP_PROVIDER).get_consumer_auth_cp() store = syspurposelib.SyncedStore(uep, consumer_uuid=self.identity.uuid) if store: store.sync() return consumer
def register(self, org, activation_keys=None, environments=None, force=None, name=None, consumerid=None, type=None, role=None, addons=None, service_level=None, usage=None, jwt_token=None, **kwargs): # We accept a kwargs argument so that the DBus object can pass the options dictionary it # receives transparently to the service via dictionary unpacking. This strategy allows the # DBus object to be more independent of the service implementation. # If there are any values in kwargs that don't map to keyword arguments defined in the message # signature we want to consider that an error. if kwargs: raise exceptions.ValidationError( _("Unknown arguments: %s") % kwargs.keys()) syspurpose = syspurposelib.read_syspurpose() save_syspurpose = False # First set new syspurpose values, if there is any if role is not None: syspurpose["role"] = role save_syspurpose = True if addons is not None: syspurpose["addons"] = addons save_syspurpose = True if service_level is not None: syspurpose["service_level_agreement"] = service_level save_syspurpose = True if usage is not None: syspurpose["usage"] = usage save_syspurpose = True # Then try to get all syspurpose values role = syspurpose.get("role", "") addons = syspurpose.get("addons", []) usage = syspurpose.get("usage", "") service_level = syspurpose.get("service_level_agreement", "") type = type or "system" options = { "activation_keys": activation_keys, "environments": environments, "force": force, "name": name, "consumerid": consumerid, "type": type, "jwt_token": jwt_token, } self.validate_options(options) environments = options["environments"] facts_dict = self.facts.get_facts() # Default to the hostname if no name is given consumer_name = options["name"] or socket.gethostname() self.plugin_manager.run("pre_register_consumer", name=consumer_name, facts=facts_dict) if consumerid: consumer = self.cp.getConsumer(consumerid) if consumer.get("type", {}).get("manifest", {}): raise exceptions.ServiceError( "Registration attempted with a consumer ID that is not of type 'system'" ) else: consumer = self.cp.registerConsumer( name=consumer_name, facts=facts_dict, owner=org, environments=environments, keys=options.get("activation_keys"), installed_products=self.installed_mgr.format_for_server(), content_tags=self.installed_mgr.tags, type=type, role=role, addons=addons, service_level=service_level, usage=usage, jwt_token=jwt_token, ) self.installed_mgr.write_cache() self.plugin_manager.run("post_register_consumer", consumer=consumer, facts=facts_dict) managerlib.persist_consumer_cert(consumer) # Now that we are registered, load the new identity self.identity.reload() # If new syspurpose values were given as arguments, then save these values to syspurpose.json now if save_syspurpose is True: syspurposelib.write_syspurpose(syspurpose) syspurpose_dict = { "service_level_agreement": consumer["serviceLevel"] if "serviceLevel" in list(consumer.keys()) else "", "role": consumer["role"] if "role" in list(consumer.keys()) else "", "usage": consumer["usage"] if "usage" in list(consumer.keys()) else "", "addons": consumer["addOns"] if "addOns" in list(consumer.keys()) else [], } # Try to do three-way merge and then save result to syspurpose.json file local_result = syspurposelib.merge_syspurpose_values( remote=syspurpose_dict, base={}) syspurposelib.write_syspurpose(local_result) # Save syspurpose attributes from consumer to cache file syspurposelib.write_syspurpose_cache(syspurpose_dict) content_access_mode_cache = inj.require(inj.CONTENT_ACCESS_MODE_CACHE) # Is information about content access mode included in consumer if "owner" not in consumer: log.warning( "Consumer does not contain any information about owner.") elif "contentAccessMode" in consumer["owner"]: log.debug( "Saving content access mode from consumer object to cache file." ) # When we know content access mode from consumer, then write it to cache file content_access_mode = consumer["owner"]["contentAccessMode"] content_access_mode_cache.set_data(content_access_mode, self.identity) content_access_mode_cache.write_cache() else: # If not, then we have to do another REST API call to get this information # It will not be included in cache file. When cache file is empty, then # it will trigger accessing REST API and saving result in cache file. log.debug( "Information about content access mode is not included in consumer" ) content_access_mode = content_access_mode_cache.read_data() # Add information about content access mode to consumer consumer["owner"]["contentAccessMode"] = content_access_mode return consumer
def register(self, org, activation_keys=None, environment=None, force=None, name=None, consumerid=None, type=None, role=None, addons=None, service_level=None, usage=None, autoheal=None, **kwargs): # We accept a kwargs argument so that the DBus object can pass the options dictionary it # receives transparently to the service via dictionary unpacking. This strategy allows the # DBus object to be more independent of the service implementation. # If there are any values in kwargs that don't map to keyword arguments defined in the message # signature we want to consider that an error. if kwargs: raise exceptions.ValidationError( _("Unknown arguments: %s") % kwargs.keys()) syspurpose = syspurposelib.read_syspurpose() save_syspurpose = False # First set new syspurpose values, if there is any if role is not None: syspurpose['role'] = role save_syspurpose = True if addons is not None: syspurpose['addons'] = addons save_syspurpose = True if service_level is not None: syspurpose['service_level_agreement'] = service_level save_syspurpose = True if usage is not None: syspurpose['usage'] = usage save_syspurpose = True # Then try to get all syspurpose values role = syspurpose.get('role', '') addons = syspurpose.get('addons', []) usage = syspurpose.get('usage', '') service_level = syspurpose.get('service_level_agreement', '') type = type or "system" options = { 'activation_keys': activation_keys, 'environment': environment, 'force': force, 'name': name, 'consumerid': consumerid, 'type': type } self.validate_options(options) environment = options['environment'] facts_dict = self.facts.get_facts() # Default to the hostname if no name is given consumer_name = options['name'] or socket.gethostname() self.plugin_manager.run("pre_register_consumer", name=consumer_name, facts=facts_dict) if consumerid: consumer = self.cp.getConsumer(consumerid) if consumer.get('type', {}).get('manifest', {}): raise exceptions.ServiceError( "Registration attempted with a consumer ID that is not of type 'system'" ) else: consumer = self.cp.registerConsumer( name=consumer_name, facts=facts_dict, owner=org, environment=environment, keys=options.get('activation_keys'), installed_products=self.installed_mgr.format_for_server(), content_tags=self.installed_mgr.tags, type=type, role=role, addons=addons, service_level=service_level, usage=usage, autoheal=autoheal) self.installed_mgr.write_cache() self.plugin_manager.run("post_register_consumer", consumer=consumer, facts=facts_dict) managerlib.persist_consumer_cert(consumer) # Now that we are registered, load the new identity self.identity.reload() # If new syspurpose values were given as arguments, then save these values to syspurpose.json now if save_syspurpose is True: syspurposelib.write_syspurpose(syspurpose) return consumer
def get_pools(self, pool_subsets=None, matches=None, pool_only=None, match_installed=None, no_overlap=None, service_level=None, show_all=None, on_date=None, future=None, after_date=None, page=0, items_per_page=0, **kwargs): # We accept a **kwargs argument so that the DBus object can pass whatever dictionary it receives # via keyword expansion. if kwargs: raise exceptions.ValidationError( _("Unknown arguments: %s") % kwargs.keys()) if isinstance(pool_subsets, str): pool_subsets = [pool_subsets] # [] or None means look at all pools if not pool_subsets: pool_subsets = ["installed", "consumed", "available"] options = { "pool_subsets": pool_subsets, "matches": matches, "pool_only": pool_only, "match_installed": match_installed, "no_overlap": no_overlap, "service_level": service_level, "show_all": show_all, "on_date": on_date, "future": future, "after_date": after_date, } self.validate_options(options) results = {} if "installed" in pool_subsets: installed = products.InstalledProducts(self.cp).list( matches, iso_dates=True) results["installed"] = [x._asdict() for x in installed] if "consumed" in pool_subsets: consumed = self.get_consumed_product_pools( service_level=service_level, matches=matches, iso_dates=True) if pool_only: results["consumed"] = [ x._asdict()["pool_id"] for x in consumed ] else: results["consumed"] = [x._asdict() for x in consumed] if "available" in pool_subsets: available = self.get_available_pools( show_all=show_all, on_date=on_date, no_overlap=no_overlap, match_installed=match_installed, matches=matches, service_level=service_level, future=future, after_date=after_date, page=int(page), items_per_page=int(items_per_page), iso_dates=True, ) if pool_only: results["available"] = [x["id"] for x in available] else: results["available"] = available return results
def register(self, org, activation_keys=None, environment=None, force=None, name=None, consumerid=None, type=None, role=None, addons=None, service_level=None, usage=None, no_insights=None, **kwargs): # We accept a kwargs argument so that the DBus object can pass the options dictionary it # receives transparently to the service via dictionary unpacking. This strategy allows the # DBus object to be more independent of the service implementation. # If there are any values in kwargs that don't map to keyword arguments defined in the message # signature we want to consider that an error. if kwargs: raise exceptions.ValidationError(_("Unknown arguments: %s") % kwargs.keys()) if no_insights is True: try: # insights-client implements a systemd path unit to trigger insights registration whenever the consumer # certificate changes. By masking this unit, we disable this automatic insights registration mechanism. # See: https://www.freedesktop.org/software/systemd/man/systemd.path.html log.debug("Disabling automatic insights registration by masking insights-register.path") with open('/dev/null', 'w') as devnull: subprocess.call(['/usr/bin/systemctl', 'mask', '--now', 'insights-register.path'], stdout=devnull, stderr=devnull) except Exception as e: # ignore failures here in case we're running in a container, or some other issue prevents disabling # insights auto-register log.warning("Failed to disable automatic insights registration: %s", e, exc_info=True) syspurpose = syspurposelib.read_syspurpose() save_syspurpose = False # First set new syspurpose values, if there is any if role is not None: syspurpose['role'] = role save_syspurpose = True if addons is not None: syspurpose['addons'] = addons save_syspurpose = True if service_level is not None: syspurpose['service_level_agreement'] = service_level save_syspurpose = True if usage is not None: syspurpose['usage'] = usage save_syspurpose = True # Then try to get all syspurpose values role = syspurpose.get('role', '') addons = syspurpose.get('addons', []) usage = syspurpose.get('usage', '') service_level = syspurpose.get('service_level_agreement', '') type = type or "system" options = { 'activation_keys': activation_keys, 'environment': environment, 'force': force, 'name': name, 'consumerid': consumerid, 'type': type } self.validate_options(options) environment = options['environment'] facts_dict = self.facts.get_facts() # Default to the hostname if no name is given consumer_name = options['name'] or socket.gethostname() self.plugin_manager.run("pre_register_consumer", name=consumer_name, facts=facts_dict) if consumerid: consumer = self.cp.getConsumer(consumerid) if consumer.get('type', {}).get('manifest', {}): raise exceptions.ServiceError( "Registration attempted with a consumer ID that is not of type 'system'") else: consumer = self.cp.registerConsumer( name=consumer_name, facts=facts_dict, owner=org, environment=environment, keys=options.get('activation_keys'), installed_products=self.installed_mgr.format_for_server(), content_tags=self.installed_mgr.tags, type=type, role=role, addons=addons, service_level=service_level, usage=usage ) self.installed_mgr.write_cache() self.plugin_manager.run("post_register_consumer", consumer=consumer, facts=facts_dict) managerlib.persist_consumer_cert(consumer) # Now that we are registered, load the new identity self.identity.reload() # If new syspurpose values were given as arguments, then save these values to syspurpose.json now if save_syspurpose is True: syspurposelib.write_syspurpose(syspurpose) return consumer
def register(self, org, activation_keys=None, environment=None, force=None, name=None, consumerid=None, **kwargs): # We accept a kwargs argument so that the DBus object can pass the options dictionary it # receives transparently to the service via dictionary unpacking. This strategy allows the # DBus object to be more independent of the service implementation. # If there are any values in kwargs that don't map to keyword arguments defined in the message # signature we want to consider that an error. if kwargs: raise exceptions.ValidationError( _("Unknown arguments: %s") % kwargs.keys()) options = { 'activation_keys': activation_keys, 'environment': environment, 'force': force, 'name': name, 'consumerid': consumerid } self.validate_options(options) environment = options['environment'] facts_dict = self.facts.get_facts() # Default to the hostname if no name is given consumer_name = options['name'] or socket.gethostname() self.plugin_manager.run("pre_register_consumer", name=consumer_name, facts=facts_dict) if consumerid: consumer = self.cp.getConsumer(consumerid) if consumer.get('type', {}).get('manifest', {}): raise exceptions.ServiceError( "Registration attempted with a consumer ID that is not of type 'system'" ) else: consumer = self.cp.registerConsumer( name=consumer_name, facts=facts_dict, owner=org, environment=environment, keys=options.get('activation_keys'), installed_products=self.installed_mgr.format_for_server(), content_tags=self.installed_mgr.tags) self.installed_mgr.write_cache() self.plugin_manager.run("post_register_consumer", consumer=consumer, facts=facts_dict) managerlib.persist_consumer_cert(consumer) # Now that we are registered, load the new identity self.identity.reload() return consumer