def test_insecure(self, start_service, get_proxy):
"""Test StartRHSMTask - setting the server.insecure RHSM config key."""
# create the task & disable SSL certificate validation
task = StartRHSMTask(verify_ssl=False)
# simulate successful systemd service start
start_service.return_value = 0
# return mock proxy
config_proxy = Mock()
get_proxy.return_value = config_proxy
# run the task and expect it to succeed
assert task.run()
# check service was started correctly
start_service.assert_called_once_with("rhsm.service")
# check proxy was requested
get_proxy.assert_called_once()
# check expected values were set on the RHSM config proxy
# - logging should be always set to DEBUG
# - SSL certificate validation should be disabled if requested
# (insecure == 1)
config_proxy.SetAll.assert_called_once_with(
{
'logging.default_log_level': get_variant(Str, 'DEBUG'),
'server.insecure': get_variant(Str, '1'),
},
''
)
def test_is_service_available_waiting(self, thread_mgr_get):
"""Test StartRHSMTask - test is_service_available() - waiting."""
# put this into a variable to fit the patch invocation on single line
is_running_import = 'pyanaconda.modules.common.task.task.Task.is_running'
with patch(is_running_import, new_callable=PropertyMock) as is_running:
# fake is_running
is_running.return_value = True
# create the task
task = StartRHSMTask()
# fake get_result()
task.get_result = Mock()
task.get_result.return_value = True
# make sure is_running is True
assert task.is_running
# assure is_running switches to False before
# the method starts waiting on the mock thread
mock_thread = Mock()
def set_running_false(thread):
is_running.return_value = False
return mock_thread
thread_mgr_get.side_effect = set_running_false
# by replacing the thread by Mock instance,
# we can avoid running the method in a thread
# as it will join() Mock instance not a real thread
assert task.is_service_available(timeout=1.0)
# check that the mock thread was joined with the
# expected timeout value
mock_thread.join.assert_called_once_with(1.0)
def test_success(self, start_service, get_proxy):
"""Test StartRHSMTask - successful task."""
# create the task
task = StartRHSMTask()
# simulate successful systemd service start
start_service.return_value = 0
# return mock proxy
config_proxy = Mock()
get_proxy.return_value = config_proxy
# run the task and expect it to succeed
assert task.run()
# check service was started correctly
start_service.assert_called_once_with("rhsm.service")
# check proxy was requested
get_proxy.assert_called_once_with(
"com.redhat.RHSM1",
"/com/redhat/RHSM1/Config",
"com.redhat.RHSM1.Config",
)
# check expected values were set on the RHSM config proxy
# - logging should be always set to DEBUG
# - SSL certificate validation should be enabled by default
# (insecure == 0)
config_proxy.SetAll.assert_called_once_with(
{
'logging.default_log_level': get_variant(Str, 'DEBUG'),
},
''
)
def test_is_service_available_timeout(self, thread_mgr_get):
"""Test StartRHSMTask - test is_service_available() - timeout."""
# put this into a variable to fit the patch invocation on single line
is_running_import = 'pyanaconda.modules.common.task.task.Task.is_running'
with patch(is_running_import, new_callable=PropertyMock) as is_running:
# fake is_running
is_running.return_value = True
# create the task
task = StartRHSMTask()
# fake get_result()
task.get_result = Mock()
task.get_result.return_value = False
# make sure is_running is True
assert task.is_running
# us a mock thread, so that it's
# join method exists immediately
mock_thread = Mock()
thread_mgr_get.return_value = mock_thread
# test the method times out
assert not task.is_service_available(timeout=1.0)
# check that the mock thread join() was called with expected
# timeout
mock_thread.join.assert_called_once_with(1.0)
def test_is_service_available_failure(self):
"""Test StartRHSMTask - test is_service_available() - failure."""
# create the task
task = StartRHSMTask()
# fake get_result()
task.get_result = Mock()
task.get_result.return_value = False
# test the method
assert not task.is_service_available(1)
def test_is_service_available_success(self):
"""Test StartRHSMTask - test is_service_available() - success."""
# create the task
task = StartRHSMTask()
# fake get_result()
task.get_result = Mock()
task.get_result.return_value = True
# test the method
assert task.is_service_available(1)
def __init__(self):
super().__init__()
# system purpose
self._valid_roles = []
self._valid_slas = []
self._valid_usage_types = []
self._system_purpose_data = SystemPurposeData()
self.system_purpose_data_changed = Signal()
self._load_valid_system_purpose_values()
# subscription request
self._subscription_request = SubscriptionRequest()
self.subscription_request_changed = Signal()
# attached subscriptions
self._attached_subscriptions = []
self.attached_subscriptions_changed = Signal()
# Insights
# What are the defaults for Red Hat Insights ?
# - during a kickstart installation, the user
# needs to opt-in by using the rhsm command
# with the --connect-to-insights option
# - during a GUI interactive installation the
# "connect to Insights" checkbox is checked by default,
# making Insights opt-out
# - in both cases the system also needs to be subscribed,
# or else the system can't be connected to Insights
self._connect_to_insights = False
self.connect_to_insights_changed = Signal()
# registration status
self.registered_changed = Signal()
self._registered = False
# subscription status
self.subscription_attached_changed = Signal()
self._subscription_attached = False
# RHSM service startup and access
self._rhsm_startup_task = StartRHSMTask(
verify_ssl=conf.payload.verify_ssl)
self._rhsm_observer = RHSMObserver(
self._rhsm_startup_task.is_service_available)
# RHSM config default values cache
self._rhsm_config_defaults = None
def test_unit_start_failed(self, start_service, get_proxy):
"""Test StartRHSMTask - systemd unit failed to start."""
# create the task
task = StartRHSMTask()
# simulate successful systemd service start
start_service.return_value = 1
# run the task and expect it to fail
assert not task.run()
# check service was started correctly
start_service.assert_called_once_with("rhsm.service")
# check proxy was not requested
get_proxy.assert_not_called()
def success_test(self, start_service, get_proxy):
"""Test StartRHSMTask - successful task."""
# create the task
task = StartRHSMTask()
# simulate successful systemd service start
start_service.return_value = 0
# return mock proxy
config_proxy = Mock()
get_proxy.return_value = config_proxy
# run the task and expect it to succeed
self.assertTrue(task.run())
# check service was started correctly
start_service.assert_called_once_with("rhsm.service")
# check proxy was requested
get_proxy.assert_called_once_with(RHSM_CONFIG)
# check expected values were set on the RHSM config proxy
config_proxy.Set.assert_called_once_with('logging.default_log_level',
get_variant(Str, 'DEBUG'), '')
class SubscriptionService(KickstartService):
"""The Subscription service."""
def __init__(self):
super().__init__()
# system purpose
self._valid_roles = []
self._valid_slas = []
self._valid_usage_types = []
self._system_purpose_data = SystemPurposeData()
self.system_purpose_data_changed = Signal()
self._load_valid_system_purpose_values()
# subscription request
self._subscription_request = SubscriptionRequest()
self.subscription_request_changed = Signal()
# attached subscriptions
self._attached_subscriptions = []
self.attached_subscriptions_changed = Signal()
# Insights
# What are the defaults for Red Hat Insights ?
# - during a kickstart installation, the user
# needs to opt-in by using the rhsm command
# with the --connect-to-insights option
# - during a GUI interactive installation the
# "connect to Insights" checkbox is checked by default,
# making Insights opt-out
# - in both cases the system also needs to be subscribed,
# or else the system can't be connected to Insights
self._connect_to_insights = False
self.connect_to_insights_changed = Signal()
# registration status
self.registered_changed = Signal()
self._registered = False
# subscription status
self.subscription_attached_changed = Signal()
self._subscription_attached = False
# RHSM service startup and access
self._rhsm_startup_task = StartRHSMTask(
verify_ssl=conf.payload.verify_ssl)
self._rhsm_observer = RHSMObserver(
self._rhsm_startup_task.is_service_available)
# RHSM config default values cache
self._rhsm_config_defaults = None
def publish(self):
"""Publish the module."""
TaskContainer.set_namespace(SUBSCRIPTION.namespace)
DBus.publish_object(SUBSCRIPTION.object_path,
SubscriptionInterface(self))
DBus.register_service(SUBSCRIPTION.service_name)
def run(self):
"""Initiate RHSM service startup before starting the main loop.
This way RHSM service can startup in parallel without blocking
startup of the Subscription module.
"""
self._rhsm_startup_task.start()
super().run()
@property
def kickstart_specification(self):
"""Return the kickstart specification."""
return SubscriptionKickstartSpecification
def process_kickstart(self, data):
"""Process the kickstart data."""
log.debug("Processing kickstart data...")
# system purpose
#
# Try if any of the values in kickstart match a valid field.
# If it does, write the valid field value instead of the value from kickstart.
#
# This way a value in kickstart that has a different case and/or trailing white space
# can still be used to preselect a value in a UI instead of being marked as a custom
# user specified value.
system_purpose_data = SystemPurposeData()
system_purpose_data.role = system_purpose.process_field(
data.syspurpose.role, self.valid_roles, "role")
system_purpose_data.sla = system_purpose.process_field(
data.syspurpose.sla, self.valid_slas, "sla")
system_purpose_data.usage = system_purpose.process_field(
data.syspurpose.usage, self.valid_usage_types, "usage")
if data.syspurpose.addons:
# As we do not have a list of valid addons available, we just use what was provided
# by the user in kickstart verbatim.
system_purpose_data.addons = data.syspurpose.addons
self.set_system_purpose_data(system_purpose_data)
# apply system purpose data, if any, so that it is all in place when we start
# talking to the RHSM service
if self.system_purpose_data.check_data_available():
self._apply_syspurpose()
# subscription request
subscription_request = SubscriptionRequest()
# credentials
if data.rhsm.organization:
subscription_request.organization = data.rhsm.organization
if data.rhsm.activation_keys:
subscription_request.activation_keys.set_secret(
data.rhsm.activation_keys)
# if org id and at least one activation key is set, switch authentication
# type to ORG & KEY
if data.rhsm.organization and data.rhsm.activation_keys:
subscription_request.type = SUBSCRIPTION_REQUEST_TYPE_ORG_KEY
# custom URLs
if data.rhsm.server_hostname:
subscription_request.server_hostname = data.rhsm.server_hostname
if data.rhsm.rhsm_baseurl:
subscription_request.rhsm_baseurl = data.rhsm.rhsm_baseurl
# HTTP proxy
if data.rhsm.proxy:
# first try to parse the proxy string from kickstart
try:
proxy = ProxyString(data.rhsm.proxy)
if proxy.host:
# ensure port is an integer and set to -1 if unknown
port = int(proxy.port) if proxy.port else -1
subscription_request.server_proxy_hostname = proxy.host
subscription_request.server_proxy_port = port
# ensure no username translates to the expected ""
# instead of the None returned by the ProxyString class
subscription_request.server_proxy_user = proxy.username or ""
subscription_request.server_proxy_password.set_secret(
proxy.password)
except ProxyStringError as e:
# should not be fatal, but definitely logged as error
message = "Failed to parse proxy for the rhsm command: {}".format(
str(e))
warnings.warn(message, KickstartParseWarning)
# set the resulting subscription request
self.set_subscription_request(subscription_request)
# insights
self.set_connect_to_insights(bool(data.rhsm.connect_to_insights))
def setup_kickstart(self, data):
"""Return the kickstart string.
NOTE: We are not writing out the rhsm command as the input can contain
sensitive data (activation keys, proxy passwords) that we would have
to omit from the output kickstart. This in turn would make the rhsm
command incomplete & would turn the output kickstart invalid as a result.
For this reason we skip the rhsm command completely in the output
kickstart.
"""
# system purpose
data.syspurpose.role = self.system_purpose_data.role
data.syspurpose.sla = self.system_purpose_data.sla
data.syspurpose.usage = self.system_purpose_data.usage
data.syspurpose.addons = self.system_purpose_data.addons
# system purpose configuration
def _load_valid_system_purpose_values(self):
"""Load lists of valid roles, SLAs and usage types.
About role/sla/validity:
- an older installation image might have older list of valid fields,
missing fields that have become valid after the image has been released
- fields that have been valid in the past might be dropped in the future
- there is no list of valid addons
Due to this we need to take into account that the listing might not always be
comprehensive and that we need to allow what might on a first glance look like
invalid values to be written to the target system.
"""
roles, slas, usage_types = system_purpose.get_valid_fields()
self._valid_roles = roles
self._valid_slas = slas
self._valid_usage_types = usage_types
@property
def valid_roles(self):
"""Return a list of valid roles.
:return: list of valid roles
:rtype: list of strings
"""
return self._valid_roles
@property
def valid_slas(self):
"""Return a list of valid SLAs.
:return: list of valid SLAs
:rtype: list of strings
"""
return self._valid_slas
@property
def valid_usage_types(self):
"""Return a list of valid usage types.
:return: list of valid usage types
:rtype: list of strings
"""
return self._valid_usage_types
@property
def system_purpose_data(self):
"""System purpose data.
A DBus structure holding information about system purpose,
such as role, sla, usage and addons.
:return: system purpose DBus structure
:rtype: DBusData instance
"""
return self._system_purpose_data
def set_system_purpose_data(self, system_purpose_data):
"""Set system purpose data.
Set the complete DBus structure containing system purpose data.
:param system_purpose_data: system purpose data structure to be set
:type system_purpose_data: DBus structure
"""
self._system_purpose_data = system_purpose_data
self.system_purpose_data_changed.emit()
log.debug("System purpose data set to %s.", system_purpose_data)
def _apply_syspurpose(self):
"""Apply system purpose information to the installation environment."""
log.debug("subscription: Applying system purpose data")
task = self.set_system_purpose_with_task()
task.run()
def set_system_purpose_with_task(self):
"""Set system purpose for the installed system with an installation task.
:return: a DBus path of an installation task
"""
rhsm_syspurpose_proxy = self.rhsm_observer.get_proxy(RHSM_SYSPURPOSE)
task = SystemPurposeConfigurationTask(
rhsm_syspurpose_proxy=rhsm_syspurpose_proxy,
system_purpose_data=self.system_purpose_data)
return task
# subscription request
@property
def subscription_request(self):
"""Subscription request.
A DBus structure holding data to be used to subscribe the system.
:return: subscription request DBus structure
:rtype: DBusData instance
"""
# Return a deep copy of the subscription request that
# has also been cleared of private data.
# Thankfully the secret Dbus structures modules
# has the get_public_copy() method that does just
# that. It creates a deep copy & clears
# all SecretData and SecretDataList instances.
return get_public_copy(self._subscription_request)
def set_subscription_request(self, subscription_request):
"""Set a subscription request.
Set the complete DBus structure containing subscription
request data.
:param subscription_request: subscription request structure to be set
:type subscription_request: DBus structure
"""
self._replace_current_subscription_request(subscription_request)
self.subscription_request_changed.emit()
log.debug("A subscription request set: %s",
str(self._subscription_request))
@property
def attached_subscriptions(self):
"""A list of attached subscriptions.
The list holds DBus structures with each structure holding information about
one attached subscription. A system that has been successfully registered and
subscribed usually has one or more subscriptions attached.
:return: list of DBus structures, one per attached subscription
:rtype: list of AttachedSubscription instances
"""
return self._attached_subscriptions
def set_attached_subscriptions(self, attached_subscriptions):
"""Set the list of attached subscriptions.
:param attached_subscriptions: list of attached subscriptions to be set
:type attached_subscriptions: list of AttachedSubscription instances
"""
self._attached_subscriptions = attached_subscriptions
self.attached_subscriptions_changed.emit()
# as there is no public setter in the DBus API, we need to emit
# the properties changed signal here manually
self.module_properties_changed.emit()
log.debug("Attached subscriptions set: %s",
str(self._attached_subscriptions))
def _replace_current_subscription_request(self, new_request):
"""Replace current subscription request without loosing sensitive data.
We need to do this to prevent blank SecretData & SecretDataList instances
from wiping out previously set secret data. The instances will be blank
every time a SubscriptionRequest that went through get_public_copy() comes
back with the secret data fields unchanged.
So what we do is depends on type of the incoming secret data:
- SECRET_TYPE_NONE - use structure from new request unchanged,
clearing previously set data (if any)
- SECRET_TYPE_HIDDEN - secret data has been set previously and
cleared when SubscriptionRequest was sent out;
put secret data from current request to the
new one to prevent it from being lost
(this will also switch the secret data
instance to SECRET_TYPE_TEXT so that
the Subscription module can read it
internally)
- SECRET_TYPE_TEXT - this is new secret entry, we can keep it as is
"""
current_request = self._subscription_request
# Red Hat account password
if new_request.account_password.type == SECRET_TYPE_HIDDEN:
new_request.account_password = copy.deepcopy(
current_request.account_password)
# activation keys used together with an organization id
if new_request.activation_keys.type == SECRET_TYPE_HIDDEN:
new_request.activation_keys = copy.deepcopy(
current_request.activation_keys)
# RHSM HTTP proxy password
if new_request.server_proxy_password.type == SECRET_TYPE_HIDDEN:
new_request.server_proxy_password = copy.deepcopy(
current_request.server_proxy_password)
# replace current request
self._subscription_request = new_request
@property
def connect_to_insights(self):
"""Indicates if the target system should be connected to Red Hat Insights.
:return: True to connect, False not to connect the target system to Insights
:rtype: bool
"""
return self._connect_to_insights
def set_connect_to_insights(self, connect):
"""Set if the target system should be connected to Red Hat Insights.
:param bool connect: set to True to connect, set to False not to connect
"""
self._connect_to_insights = connect
self.connect_to_insights_changed.emit()
log.debug("Connect target system to Insights set to: %s",
self._connect_to_insights)
# registration status
@property
def registered(self):
"""Return True if the system has been registered.
NOTE: Together with the subscription_attached property
the registered property can be used to detect that
the system is registered but has not subscription
attached. This is generally a sign something went
wrong, usually when trying to attach subscription.
:return: True if the system has been registered, False otherwise
:rtype: bool
"""
return self._registered
def set_registered(self, system_registered):
"""Set if the system is registered.
:param bool system_registered: True if system has been registered, False otherwise
"""
self._registered = system_registered
self.registered_changed.emit()
# as there is no public setter in the DBus API, we need to emit
# the properties changed signal here manually
self.module_properties_changed.emit()
log.debug("System registered set to: %s", system_registered)
# subscription status
@property
def subscription_attached(self):
"""Return True if a subscription has been attached to the system.
:return: True if a subscription has been attached to the system, False otherwise
:rtype: bool
"""
return self._subscription_attached
def set_subscription_attached(self, system_subscription_attached):
"""Set a subscription has been attached to the system.
:param bool system_registered: True if subscription has been attached, False otherwise
"""
self._subscription_attached = system_subscription_attached
self.subscription_attached_changed.emit()
# as there is no public setter in the DBus API, we need to emit
# the properties changed signal here manually
self.module_properties_changed.emit()
log.debug("Subscription attached set to: %s",
system_subscription_attached)
# tasks
def install_with_tasks(self):
"""Return the installation tasks of this module.
Order of execution is important:
- before transferring subscription tokens we need to restore
the INFO log level in rhsm.conf or else target system will
end up with RHSM logging in DEBUG mode
- transfer subscription tokens
- connect to insights, this can run only once subscription
tokens are in place on the target system or else it would
fail as Insights client needs the subscription tokens to
authenticate to the Red Hat Insights online service
:returns: list of installation tasks
"""
return [
RestoreRHSMDefaultsTask(
rhsm_config_proxy=self.rhsm_observer.get_proxy(RHSM_CONFIG)),
TransferSubscriptionTokensTask(
sysroot=conf.target.system_root,
transfer_subscription_tokens=self.subscription_attached),
ConnectToInsightsTask(
sysroot=conf.target.system_root,
subscription_attached=self.subscription_attached,
connect_to_insights=self.connect_to_insights)
]
# RHSM DBus API access
@property
def rhsm_observer(self):
"""Provide access to the RHSM DBus service observer.
This observer handles various peculiarities of the
RHSM DBus API startup and should be used as the
only access point to the RHSM Dbus API.
If you need to RHSM DBus API object, just call the
get_proxy() method of the observer with object
identifier.
:return: RHSM DBus API observer
:rtype: RHSMObserver instance
"""
return self._rhsm_observer
def _flatten_rhsm_nested_dict(self, nested_dict):
"""Convert the GetAll() returned nested dict into a flat one.
RHSM returns a nested dict with categories on top
and category keys & values inside. This is not convenient
for setting keys based on original values, so
let's normalize the dict to the flat key based
structure similar to what's used by SetAll().
:param dict nested_dict: the nested dict returned by GetAll()
:return: flat key/value dictionary, similar to format used by SetAll()
:rtype: dict
"""
flat_dict = {}
for category_key, category_dict in nested_dict.items():
for key, value in category_dict.items():
flat_key = "{}.{}".format(category_key, key)
flat_dict[flat_key] = value
return flat_dict
def get_rhsm_config_defaults(self):
"""Return RHSM config default values.
We need to have these available in case the user decides
to return to default values from a custom value at
runtime.
This method is lazy evaluated, the first call it fetches
the full config dict from RHSM and subsequent calls are
then served from cache.
Due to this it is important not to set RHSM configuration
values before first calling this method to populate the cache
or else the method might return non-default (Anaconda overwritten)
data.
NOTE: While RHSM GetAll() DBus call returns a nested dictionary,
we turn it into a flat key/value dict, in the same format SetAll()
uses.
:return : dictionary of default RHSM configuration values
:rtype: dict
"""
if self._rhsm_config_defaults is None:
# config defaults cache not yet populated, do it now
proxy = self.rhsm_observer.get_proxy(RHSM_CONFIG)
# turn the variant into a dict with get_native()
nested_dict = get_native(proxy.GetAll(""))
# flatten the nested dict
flat_dict = self._flatten_rhsm_nested_dict(nested_dict)
self._rhsm_config_defaults = flat_dict
return self._rhsm_config_defaults
def set_rhsm_config_with_task(self):
"""Set RHSM config values based on current subscription request.
:return: a DBus path of an installation task
"""
# NOTE: we access self._subscription_request directly
# to avoid the sensitive data clearing happening
# in the subscription_request property getter
rhsm_config_proxy = self.rhsm_observer.get_proxy(RHSM_CONFIG)
task = SetRHSMConfigurationTask(
rhsm_config_proxy=rhsm_config_proxy,
rhsm_config_defaults=self.get_rhsm_config_defaults(),
subscription_request=self._subscription_request)
return task
def register_username_password_with_task(self):
"""Register with username and password based on current subscription request.
:return: a DBus path of an installation task
"""
# NOTE: we access self._subscription_request directly
# to avoid the sensitive data clearing happening
# in the subscription_request property getter
username = self._subscription_request.account_username
password = self._subscription_request.account_password.value
register_server_proxy = self.rhsm_observer.get_proxy(
RHSM_REGISTER_SERVER)
task = RegisterWithUsernamePasswordTask(
rhsm_register_server_proxy=register_server_proxy,
username=username,
password=password)
# if the task succeeds, it means the system has been registered
task.succeeded_signal.connect(lambda: self.set_registered(True))
return task
def register_organization_key_with_task(self):
"""Register with organization and activation key(s) based on current subscription request.
:return: a DBus path of an installation task
"""
# NOTE: we access self._subscription_request directly
# to avoid the sensitive data clearing happening
# in the subscription_request property getter
organization = self._subscription_request.organization
activation_keys = self._subscription_request.activation_keys.value
register_server_proxy = self.rhsm_observer.get_proxy(
RHSM_REGISTER_SERVER)
task = RegisterWithOrganizationKeyTask(
rhsm_register_server_proxy=register_server_proxy,
organization=organization,
activation_keys=activation_keys)
# if the task succeeds, it means the system has been registered
task.succeeded_signal.connect(lambda: self.set_registered(True))
return task
def unregister_with_task(self):
"""Unregister the system.
:return: a DBus path of an installation task
"""
rhsm_unregister_proxy = self.rhsm_observer.get_proxy(RHSM_UNREGISTER)
task = UnregisterTask(rhsm_unregister_proxy=rhsm_unregister_proxy)
# we will no longer be registered and subscribed if the task is successful,
# so set the corresponding properties appropriately
task.succeeded_signal.connect(lambda: self.set_registered(False))
task.succeeded_signal.connect(
lambda: self.set_subscription_attached(False))
# and clear attached subscriptions
task.succeeded_signal.connect(
lambda: self.set_attached_subscriptions([]))
return task
def attach_subscription_with_task(self):
"""Attach a subscription.
This should only be run on a system that has been successfully registered.
Attached subscription depends on system type, system purpose data
and entitlements available for the account that has been used for registration.
:return: a DBus path of an installation task
"""
sla = self.system_purpose_data.sla
rhsm_attach_proxy = self.rhsm_observer.get_proxy(RHSM_ATTACH)
task = AttachSubscriptionTask(rhsm_attach_proxy=rhsm_attach_proxy,
sla=sla)
# if the task succeeds, it means a subscription has been attached
task.succeeded_signal.connect(
lambda: self.set_subscription_attached(True))
return task
def _set_system_subscription_data(self, system_subscription_data):
"""A helper method invoked in ParseAttachedSubscritionsTask completed signal.
:param system_subscription_data: a named tuple holding attached subscriptions
and final system purpose data
"""
self.set_attached_subscriptions(
system_subscription_data.attached_subscriptions)
self.set_system_purpose_data(
system_subscription_data.system_purpose_data)
def parse_attached_subscriptions_with_task(self):
"""Parse attached subscriptions with task.
Parse data about attached subscriptions and final system purpose data.
This data is available as JSON strings via the RHSM DBus API.
:return: a DBus path of an installation task
"""
rhsm_entitlement_proxy = self.rhsm_observer.get_proxy(RHSM_ENTITLEMENT)
rhsm_syspurpose_proxy = self.rhsm_observer.get_proxy(RHSM_SYSPURPOSE)
task = ParseAttachedSubscriptionsTask(
rhsm_entitlement_proxy=rhsm_entitlement_proxy,
rhsm_syspurpose_proxy=rhsm_syspurpose_proxy)
# if the task succeeds, set attached subscriptions and system purpose data
task.succeeded_signal.connect(
lambda: self._set_system_subscription_data(task.get_result()))
return task
def collect_requirements(self):
"""Return installation requirements for this module.
:return: a list of requirements
"""
requirements = []
# check if we need the insights-client package, which is needed to connect the
# target system to Red Hat Insights
if self.subscription_attached and self.connect_to_insights:
# establishing a connection to Red Hat Insights has been requested
# and we need the insights-client package to be present in the
# target system chroot for that
requirements.append(
Requirement.for_package(
"insights-client",
reason=
"Needed to connect the target system to Red Hat Insights.")
)
return requirements