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)