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
