def test_name_uniqueness_properties(self):
module1 = URLSourceModule()
interface1 = URLSourceInterface(module1)
module2 = URLSourceModule()
interface2 = URLSourceInterface(module2)
conf1 = RepoConfigurationData.from_structure(interface1.RepoConfiguration)
conf2 = RepoConfigurationData.from_structure(interface2.RepoConfiguration)
assert conf1.name != conf2.name
def name_uniqueness_properties_test(self):
module1 = URLSourceModule()
interface1 = URLSourceInterface(module1)
module2 = URLSourceModule()
interface2 = URLSourceInterface(module2)
conf1 = RepoConfigurationData.from_structure(
interface1.RepoConfiguration)
conf2 = RepoConfigurationData.from_structure(
interface2.RepoConfiguration)
self.assertNotEqual(conf1.name, conf2.name)
def _add_base_repository(self):
"""Add the base repository.
Try to add a valid base repository to the DNF base.
:raise: DNFManagerError if the repo is invalid
"""
# Get the repo configuration of the first source.
data = RepoConfigurationData.from_structure(
self.proxy.GetRepoConfigurations()[0])
log.debug("Using the repo configuration: %s", data)
data.name = constants.BASE_REPO_NAME
# Process the treeinfo metadata.
treeinfo_base_repo_url = self._reload_treeinfo_metadata(data)
if treeinfo_base_repo_url:
data.type = URL_TYPE_BASEURL
data.url = treeinfo_base_repo_url
log.debug("Add the base repository at %s.", data.url)
try:
self._dnf_manager.add_repository(data)
self._dnf_manager.load_repository(data.name)
except DNFManagerError as e:
log.error("The base repository is invalid: %s", str(e))
self._dnf_manager.remove_repository(data.name)
raise e
def SetRepoConfiguration(self, repo_configuration: Structure):
"""Set this repository configuration.
:param repo_configuration: configuration structure of this repository
:type repo_configuration: RepoConfigurationData structure
"""
self.implementation.set_repo_configuration(
RepoConfigurationData.from_structure(repo_configuration))
def _get_url(self):
"""Get the URL of the current source."""
source_proxy = self.payload.get_source_proxy()
if source_proxy.Type == SOURCE_TYPE_URL:
repo_configuration = RepoConfigurationData.from_structure(
source_proxy.RepoConfiguration)
return repo_configuration.url
return ""
def set_invalid_proxy_properties_test(self):
data = RepoConfigurationData()
data.proxy = "https:///no/server/hostname"
with self.assertRaises(InvalidValueError):
self._check_dbus_property("RepoConfiguration",
RepoConfigurationData.to_structure(data))
# new value shouldn't be set
old_data = self.url_source_interface.RepoConfiguration
old_data = RepoConfigurationData.from_structure(old_data)
self.assertEqual(old_data.proxy, "")
def set_invalid_url_type_properties_test(self):
data = RepoConfigurationData()
data.url = "http://test"
data.type = "DOES-NOT-EXISTS"
with self.assertRaises(InvalidValueError):
self._check_dbus_property("RepoConfiguration",
RepoConfigurationData.to_structure(data))
# new value shouldn't be set
old_data = self.url_source_interface.RepoConfiguration
old_data = RepoConfigurationData.from_structure(old_data)
self.assertEqual(old_data.url, "")
self.assertEqual(old_data.type, URL_TYPE_BASEURL)
def _get_proxy_url(self):
"""Get a proxy of the current source.
:return: a proxy or None
"""
source_proxy = self.get_source_proxy()
source_type = source_proxy.Type
if source_type != SOURCE_TYPE_URL:
return None
data = RepoConfigurationData.from_structure(
source_proxy.RepoConfiguration)
return data.proxy
def ssl_configuration_is_not_empty_properties_test(self):
ssl_conf = SSLConfigurationData()
ssl_conf.ca_cert_path = "file:///my/root/house"
ssl_conf.client_cert_path = "file:///badge/with/yellow/access"
ssl_conf.client_key_path = "file:///skeleton/head/key"
repo_data = RepoConfigurationData()
repo_data.ssl_configuration = ssl_conf
self.url_source_interface.SetRepoConfiguration(
RepoConfigurationData.to_structure(repo_data))
repo_data_2 = RepoConfigurationData.from_structure(
self.url_source_interface.RepoConfiguration)
self.assertFalse(repo_data_2.ssl_configuration.is_empty())
def _set_source_configuration_from_opts(self, opts):
"""Configure the source based on the Anaconda options."""
source_proxy = self.get_source_proxy()
if source_proxy.Type == SOURCE_TYPE_URL:
# Get the repo configuration.
repo_configuration = RepoConfigurationData.from_structure(
source_proxy.RepoConfiguration)
if opts.proxy:
repo_configuration.proxy = opts.proxy
if not conf.payload.verify_ssl:
repo_configuration.ssl_verification_enabled = conf.payload.verify_ssl
# Update the repo configuration.
source_proxy.RepoConfiguration = \
RepoConfigurationData.to_structure(repo_configuration)
def set_from_opts(self, opts):
"""Set the payload from the Anaconda cmdline options.
:param opts: a namespace of options
"""
# Set the source based on opts.method if it isn't already set
# - opts.method is currently set by command line/boot options
if opts.method and (not self.proxy.Sources or self._is_source_default()):
try:
source = SourceFactory.parse_repo_cmdline_string(opts.method)
except PayloadSourceTypeUnrecognized:
log.error("Unknown method: %s", opts.method)
else:
source_proxy = source.create_proxy()
set_source(self.proxy, source_proxy)
# Set up the current source.
source_proxy = self.get_source_proxy()
if source_proxy.Type == SOURCE_TYPE_URL:
# Get the repo configuration.
repo_configuration = RepoConfigurationData.from_structure(
source_proxy.RepoConfiguration
)
if opts.proxy:
repo_configuration.proxy = opts.proxy
if not conf.payload.verify_ssl:
repo_configuration.ssl_verification_enabled = conf.payload.verify_ssl
# Update the repo configuration.
source_proxy.SetRepoConfiguration(
RepoConfigurationData.to_structure(repo_configuration)
)
# Set up packages.
if opts.multiLib:
configuration = self.get_packages_configuration()
configuration.multilib_policy = MULTILIB_POLICY_ALL
self.set_packages_configuration(configuration)
# Reset all the other things now that we have new configuration.
self._configure()
def update_base_repo(self, fallback=True, checkmount=True):
"""Update the base repository from the DBus source."""
log.info("Configuring the base repo")
self._reset_configuration()
disabled_treeinfo_repo_names = self._cleanup_old_treeinfo_repositories()
# Find the source and its type.
source_proxy = self.get_source_proxy()
source_type = source_proxy.Type
# Change the default source to CDROM if there is a valid install media.
# FIXME: Set up the default source earlier.
if checkmount and self._is_source_default() and find_optical_install_media():
source_type = SOURCE_TYPE_CDROM
source_proxy = create_source(source_type)
set_source(self.proxy, source_proxy)
# Set up the source.
set_up_sources(self.proxy)
# Read in all the repos from the installation environment, make a note of which
# are enabled, and then disable them all. If the user gave us a method, we want
# to use that instead of the default repos.
self._base.read_all_repos()
# Enable or disable updates.
self.set_updates_enabled(self._updates_enabled)
# Repo files are always loaded from the system.
# When reloaded their state needs to be synchronized with the user configuration.
# So we disable them now and enable them later if required.
enabled = []
with self._repos_lock:
for repo in self._base.repos.iter_enabled():
enabled.append(repo.id)
repo.disable()
# Add a new repo.
if source_type not in SOURCE_REPO_FILE_TYPES:
# Get the repo configuration of the first source.
data = RepoConfigurationData.from_structure(
self.proxy.GetRepoConfigurations()[0]
)
log.debug("Using the repo configuration: %s", data)
# Get the URL.
install_tree_url = data.url if data.type == URL_TYPE_BASEURL else ""
mirrorlist = data.url if data.type == URL_TYPE_MIRRORLIST else ""
metalink = data.url if data.type == URL_TYPE_METALINK else ""
# Fallback to the installation root.
base_repo_url = install_tree_url
try:
self._refresh_install_tree(data)
self._base.conf.releasever = self._get_release_version(install_tree_url)
base_repo_url = self._get_base_repo_location(install_tree_url)
log.debug("releasever from %s is %s", base_repo_url, self._base.conf.releasever)
self._load_treeinfo_repositories(base_repo_url, disabled_treeinfo_repo_names, data)
except configparser.MissingSectionHeaderError as e:
log.error("couldn't set releasever from base repo (%s): %s", source_type, e)
try:
base_ksrepo = self.data.RepoData(
name=constants.BASE_REPO_NAME,
baseurl=base_repo_url,
mirrorlist=mirrorlist,
metalink=metalink,
noverifyssl=not data.ssl_verification_enabled,
proxy=data.proxy,
sslcacert=data.ssl_configuration.ca_cert_path,
sslclientcert=data.ssl_configuration.client_cert_path,
sslclientkey=data.ssl_configuration.client_key_path
)
self._add_repo_to_dnf(base_ksrepo)
self._fetch_md(base_ksrepo.name)
except (MetadataError, PayloadError) as e:
log.error("base repo (%s/%s) not valid -- removing it",
source_type, base_repo_url)
log.error("reason for repo removal: %s", e)
with self._repos_lock:
self._base.repos.pop(constants.BASE_REPO_NAME, None)
if not fallback:
with self._repos_lock:
for repo in self._base.repos.iter_enabled():
self._disable_repo(repo.id)
return
# Fallback to the default source
#
# This is at the moment CDN on RHEL
# and closest mirror everywhere else.
tear_down_sources(self.proxy)
source_type = conf.payload.default_source
source_proxy = create_source(source_type)
set_source(self.proxy, source_proxy)
set_up_sources(self.proxy)
# We need to check this again separately in case REPO_FILES were set above.
if source_type in SOURCE_REPO_FILE_TYPES:
# If this is a kickstart install, just return now as we normally do not
# want to read the on media repo files in such a case. On the other hand,
# the local repo files are a valid use case if the system is subscribed
# and the CDN is selected as the installation source.
if self.source_type == SOURCE_TYPE_CDN and is_module_available(SUBSCRIPTION):
# only check if the Subscription module is available & CDN is the
# installation source
subscription_proxy = SUBSCRIPTION.get_proxy()
load_cdn_repos = subscription_proxy.IsSubscriptionAttached
else:
# if the Subscription module is not available, we simply can't use
# the CDN repos, making our decision here simple
load_cdn_repos = False
if flags.automatedInstall and not load_cdn_repos:
return
# Otherwise, fall back to the default repos that we disabled above
with self._repos_lock:
for (id_, repo) in self._base.repos.items():
if id_ in enabled:
log.debug("repo %s: fall back enabled from default repos", id_)
repo.enable()
for repo in self.addons:
ksrepo = self.get_addon_repo(repo)
if ksrepo.is_harddrive_based():
ksrepo.baseurl = self._setup_harddrive_addon_repo(ksrepo)
log.debug("repo %s: mirrorlist %s, baseurl %s, metalink %s",
ksrepo.name, ksrepo.mirrorlist, ksrepo.baseurl, ksrepo.metalink)
# one of these must be set to create new repo
if not (ksrepo.mirrorlist or ksrepo.baseurl or ksrepo.metalink or
ksrepo.name in self._base.repos):
raise PayloadSetupError("Repository %s has no mirror, baseurl or "
"metalink set and is not one of "
"the pre-defined repositories" %
ksrepo.name)
self._add_repo_to_dnf(ksrepo)
with self._repos_lock:
# disable unnecessary repos
for repo in self._base.repos.iter_enabled():
id_ = repo.id
if 'source' in id_ or 'debuginfo' in id_:
self._disable_repo(id_)
elif constants.isFinal and 'rawhide' in id_:
self._disable_repo(id_)
# fetch md for enabled repos
enabled_repos = self._enabled_repos
for repo_name in self.addons:
if repo_name in enabled_repos:
self._fetch_md(repo_name)
def test_default_cost_properties(self):
repo_conf = self.url_source_interface.RepoConfiguration
repo_conf = RepoConfigurationData.from_structure(repo_conf)
assert repo_conf.cost == DNF_DEFAULT_REPO_COST
def test_ssl_configuration_is_empty_properties(self):
repo_data = self.url_source_interface.RepoConfiguration
repo_conf = RepoConfigurationData.from_structure(repo_data)
ssl_conf = repo_conf.ssl_configuration
assert ssl_conf.is_empty()
def default_cost_properties_test(self):
repo_conf = self.url_source_interface.RepoConfiguration
repo_conf = RepoConfigurationData.from_structure(repo_conf)
self.assertEqual(repo_conf.cost, DNF_DEFAULT_REPO_COST)
