def set_syspurpose_values(self, syspurpose_values):
"""
Try to set system purpose values
:param syspurpose_values: Dictionary with system purpose values
:return: Dictionary with local result
"""
Server.temporary_disable_dir_watchers({SYSPURPOSE_WATCHER})
if self.identity.is_valid() and self.cp.has_capability("syspurpose"):
local_result = merge_syspurpose_values(
local=syspurpose_values,
uep=self.cp,
consumer_uuid=self.identity.uuid)
write_syspurpose(local_result)
synced_store = get_sys_purpose_store()
sync_result = synced_store.sync()
result = sync_result.result
else:
local_result = merge_syspurpose_values(local=syspurpose_values,
remote={},
base={})
write_syspurpose(local_result)
result = local_result
Server.enable_dir_watchers({SYSPURPOSE_WATCHER})
return result
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,
**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)
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)
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,
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)
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)
return consumer