def _tear_down_existing_source(self):
source_proxy = self.payload.get_source_proxy()
if source_proxy.Type == constants.SOURCE_TYPE_HDD and source_proxy.Partition:
unmark_protected_device(source_proxy.Partition)
tear_down_sources(self.payload.proxy)
def _reset_configuration(self):
tear_down_sources(self.proxy)
self._reset_additional_repos()
self._install_tree_metadata = None
self.tx_id = None
self._dnf_manager.clear_cache()
self._dnf_manager.configure_proxy(self._get_proxy_url())
def _reset_configuration(self):
tear_down_sources(self.proxy)
self._reset_additional_repos()
self.tx_id = None
self._dnf_manager.clear_cache()
self._dnf_manager.reset_substitution()
self._dnf_manager.configure_proxy(self._get_proxy_url())
def unsetup(self):
"""Invalidate a previously setup payload."""
from pyanaconda.modules.payloads.payload.rpm_ostree.installation import \
TearDownOSTreeMountTargetsTask
task = TearDownOSTreeMountTargetsTask(
mount_points=self._internal_mounts)
task.run()
tear_down_sources(self.proxy)
def tear_down_sources_test(self, proxy_getter):
payload_proxy = PAYLOADS.get_proxy("/my/payload")
payload_proxy.TearDownSourcesWithTask.return_value = "/my/task"
task_proxy = PAYLOADS.get_proxy("/my/task")
task_proxy.IsRunning = False
tear_down_sources(payload_proxy)
payload_proxy.TearDownSourcesWithTask.assert_called_once_with()
task_proxy.Start.assert_called_once_with()
task_proxy.Finish.assert_called_once_with()
def unsetup(self):
"""Invalidate a previously setup payload."""
super().unsetup()
for mount in reversed(self._internal_mounts):
try:
payload_utils.unmount(mount)
except CalledProcessError as e:
log.debug("unmounting %s failed: %s", mount, str(e))
tear_down_sources(self.proxy)
def _tear_down_existing_source(payload):
"""Tear down existing payload, so we can set a new one.
:param payload: Anaconda payload instance
"""
source_proxy = payload.get_source_proxy()
if source_proxy.Type == SOURCE_TYPE_HDD and source_proxy.Partition:
unmark_protected_device(source_proxy.Partition)
tear_down_sources(payload.proxy)
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 unsetup(self):
self._configure()
self._repoMD_list = []
self._install_tree_metadata = None
tear_down_sources(self.proxy)
def unsetup(self):
self._configure()
tear_down_sources(self.proxy)
def update_base_repo(self, fallback=True, try_media=True):
"""Update the base repository from the DBus source."""
log.debug("Tearing down sources")
tear_down_sources(self.proxy)
self._tear_down_additional_sources()
log.debug("Preparing the DNF base")
self.tx_id = None
self._dnf_manager.clear_cache()
self._dnf_manager.reset_substitution()
self._dnf_manager.configure_base(self.get_packages_configuration())
self._dnf_manager.configure_proxy(self._get_proxy_url())
self._dnf_manager.dump_configuration()
self._dnf_manager.read_system_repositories()
log.info("Configuring the base repo")
# 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 try_media 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)
# Add a new repo.
if source_type not in SOURCE_REPO_FILE_TYPES:
try:
self._add_base_repository()
except DNFManagerError as e:
# Fail if the fallback is not enabled.
if not fallback:
raise e
# 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:
# Remove all treeinfo repositories.
self._remove_treeinfo_repositories()
# 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 flags.automatedInstall and not self._is_cdn_set_up():
return
# Otherwise, fall back to the default repos that we disabled above
self._enable_system_repositories()
self._include_additional_repositories()
self._validate_enabled_repositories()
def unsetup(self):
self._dnf_manager.reset_base()
tear_down_sources(self.proxy)
