def test_set_rhsm_config_tast_restore_default_value(self):
"""Test the SetRHSMConfigurationTask task - restore default values."""
mock_config_proxy = Mock()
# RHSM config default values
default_config = {
SetRHSMConfigurationTask.CONFIG_KEY_SERVER_HOSTNAME:
"server.example.com",
SetRHSMConfigurationTask.CONFIG_KEY_SERVER_PROXY_HOSTNAME:
"proxy.example.com",
SetRHSMConfigurationTask.CONFIG_KEY_SERVER_PROXY_PORT: "1000",
SetRHSMConfigurationTask.CONFIG_KEY_SERVER_PROXY_USER: "******",
SetRHSMConfigurationTask.CONFIG_KEY_SERVER_PROXY_PASSWORD:
"******",
SetRHSMConfigurationTask.CONFIG_KEY_RHSM_BASEURL:
"cdn.example.com",
"key_anaconda_does_not_use_1": "foo1",
"key_anaconda_does_not_use_2": "foo2"
}
# a representative subscription request, with server hostname and rhsm baseurl
# set to blank
request = SubscriptionRequest()
request.type = SUBSCRIPTION_REQUEST_TYPE_ORG_KEY
request.organization = "123456789"
request.account_username = "******"
request.server_hostname = ""
request.rhsm_baseurl = ""
request.server_proxy_hostname = "proxy.foo.com"
request.server_proxy_port = 9001
request.server_proxy_user = "******"
request.account_password.set_secret("foo_password")
request.activation_keys.set_secret(["key1", "key2", "key3"])
request.server_proxy_password.set_secret("foo_proxy_password")
# create a task
task = SetRHSMConfigurationTask(rhsm_config_proxy=mock_config_proxy,
rhsm_config_defaults=default_config,
subscription_request=request)
task.run()
# check that the server.hostname and rhsm.baseurl keys are set
# to the default value
expected_dict = {
"server.hostname": get_variant(Str, "server.example.com"),
"server.proxy_hostname": get_variant(Str, "proxy.foo.com"),
"server.proxy_port": get_variant(Str, "9001"),
"server.proxy_user": get_variant(Str, "foo_proxy_user"),
"server.proxy_password": get_variant(Str, "foo_proxy_password"),
"rhsm.baseurl": get_variant(Str, "cdn.example.com")
}
mock_config_proxy.SetAll.assert_called_once_with(expected_dict, "")
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))