def test_consumerid_with_distributor_id(self):
self.stub_cp_provider.basic_auth_cp = Mock('rhsm.connection.UEPConnection', new_callable=StubUEP)
self._inject_mock_invalid_consumer()
cmd = RegisterCommand()
self._inject_ipm()
self.mock_register.register.side_effect = exceptions.ServiceError()
with Capture(silent=True):
with self.assertRaises(SystemExit) as e:
cmd.main(['register', '--consumerid=TaylorSwift', '--username=testuser1', '--password=password', '--org=test_org'])
self.assertEqual(e.code, os.EX_USAGE)
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 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