def set_source_cdrom(self): """ Switch to cdrom install source """ # clean any old HDD ISO sources self._tear_down_existing_source() cdrom_source_proxy = create_source(constants.SOURCE_TYPE_CDROM) set_source(self.payload.proxy, cdrom_source_proxy)
def set_source_closest_mirror(self): """ Switch to the closest mirror install source """ # clean any old HDD ISO sources self._tear_down_existing_source() repo_files_source_proxy = create_source(constants.SOURCE_TYPE_CLOSEST_MIRROR) set_source(self.payload.proxy, repo_files_source_proxy)
def set_source_hmc(self): """ Switch to install source via HMC """ # clean any old HDD ISO sources self._tear_down_existing_source() hmc_source_proxy = create_source(constants.SOURCE_TYPE_HMC) set_source(self.payload.proxy, hmc_source_proxy)
def create_proxy(self): """Create and set up a DBus source. :return: a DBus proxy of a source """ source_proxy = create_source(SOURCE_TYPE_HDD) source_proxy.SetPartition(self.partition) source_proxy.SetDirectory(self.path) return source_proxy
def set_source_cdn(payload): """Switch to the CDN installation source. :param payload: Anaconda payload instance """ _tear_down_existing_source(payload) new_source_proxy = create_source(SOURCE_TYPE_CDN) set_source(payload.proxy, new_source_proxy)
def create_proxy(self): """Create and set up a DBus source. :return: a DBus proxy of a source """ source_proxy = create_source(SOURCE_TYPE_NFS) source_url = create_nfs_url(self.server, self.path, self.options) source_proxy.SetURL(source_url) return source_proxy
def create_source_test(self, proxy_getter): """Test the create_source function.""" payloads_proxy = PAYLOADS.get_proxy() payloads_proxy.CreateSource.return_value = "/my/source" source_proxy = PAYLOADS.get_proxy("/my/source") source_proxy.Type = SOURCE_TYPE_CDROM self.assertEqual(create_source(SOURCE_TYPE_CDROM), source_proxy) payloads_proxy.CreateSource.assert_called_once_with(SOURCE_TYPE_CDROM)
def switch_source(payload, source_type): """Switch to an installation source. :param payload: Anaconda payload instance :param source_type: installation source type """ _tear_down_existing_source(payload) new_source_proxy = create_source(source_type) set_source(payload.proxy, new_source_proxy)
def set_from_opts(self, opts): """Add the flatpak source if available.""" flatpak_source = create_source(SOURCE_TYPE_FLATPAK) if not flatpak_source.IsAvailable(): log.debug("The flatpak source is not available.") return sources = self.proxy.Sources sources.append(get_object_path(flatpak_source)) self.proxy.SetSources(sources)
def set_source_nfs(self, server, directory, opts): """ Switch to NFS install source """ # clean any old HDD ISO sources self._tear_down_existing_source() nfs_url = create_nfs_url(server, directory, opts) nfs_source_proxy = create_source(constants.SOURCE_TYPE_NFS) nfs_source_proxy.URL = nfs_url set_source(self.payload.proxy, nfs_source_proxy)
def create_proxy(self): """Create and set up a DBus source. :return: a DBus proxy of a source """ source_proxy = create_source(SOURCE_TYPE_URL) repo_configuration = RepoConfigurationData() repo_configuration.type = URL_TYPE_BASEURL repo_configuration.url = self.path source_proxy.SetRepoConfiguration( RepoConfigurationData.to_structure(repo_configuration)) return source_proxy
def create_proxy(self): """Create and set up a DBus source. :return: a DBus proxy of a source """ source_proxy = create_source(SOURCE_TYPE_URL) repo_configuration = RepoConfigurationData() repo_configuration.type = self.url_type repo_configuration.url = self.url source_proxy.RepoConfiguration = \ RepoConfigurationData.to_structure(repo_configuration) return source_proxy
def set_source_url(self, url, url_type=constants.URL_TYPE_BASEURL, proxy=None): """ Switch to install source specified by URL """ # clean any old HDD ISO sources self._tear_down_existing_source() url_source_proxy = create_source(constants.SOURCE_TYPE_URL) repo_conf = RepoConfigurationData() repo_conf.url = url repo_conf.type = url_type repo_conf.proxy = proxy or "" url_source_proxy.SetRepoConfiguration( RepoConfigurationData.to_structure(repo_conf) ) set_source(self.payload.proxy, url_source_proxy)
def set_source_hdd_iso(self, device_name, iso_path): """ Switch to the HDD ISO install source :param device_name: name of the partition hosting the ISO :type device_name: string :param iso_path: full path to the source ISO file :type iso_path: string """ self._tear_down_existing_source() new_source_proxy = create_source(constants.SOURCE_TYPE_HDD) new_source_proxy.Partition = device_name # the / gets stripped off by payload.ISO_image new_source_proxy.Directory = "/" + iso_path # protect current device_name mark_protected_device(device_name) set_source(self.payload.proxy, new_source_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 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 create_proxy(self): """Create and set up a DBus source. :return: a DBus proxy of a source """ return create_source(SOURCE_TYPE_HMC)