def configure_proxy(self, url): """Configure the proxy of the DNF base. :param url: a proxy URL or None """ base = self._base # Reset the proxy configuration. base.conf.proxy = "" base.conf.proxy_username = "" base.conf.proxy_password = "" # No URL is provided. if not url: return # Parse the given URL. try: proxy = ProxyString(url) except ProxyStringError as e: log.error("Failed to parse the proxy '%s': %s", url, e) return # Set the proxy configuration. log.info("Using '%s' as a proxy.", url) base.conf.proxy = proxy.noauth_url base.conf.proxy_username = proxy.username or "" base.conf.proxy_password = proxy.password or ""
def set_up_proxy_variables(proxy): """Set up proxy environmental variables. Set up proxy environmental variables so that %pre and %post scripts can use it as well as curl, libreport, etc. :param proxy: a string with the proxy URL """ if not proxy: log.debug("Don't set up proxy variables.") return try: proxy = ProxyString(proxy) except ProxyStringError as e: log.info("Failed to parse proxy \"%s\": %s", proxy, e) else: # Set environmental variables to be used by pre/post scripts util.setenv("PROXY", proxy.noauth_url) util.setenv("PROXY_USER", proxy.username or "") util.setenv("PROXY_PASSWORD", proxy.password or "") # Variables used by curl, libreport, etc. util.setenv("http_proxy", proxy.url) util.setenv("ftp_proxy", proxy.url) util.setenv("HTTPS_PROXY", proxy.url)
def run(self): while True: response = self.window.run() if response == 1: if self.on_ok_clicked(): # Ok clicked with valid input, save the proxy data if self._proxy_check.get_active(): url = self._proxy_url_entry.get_text() if self._auth_check.get_active(): username = self._proxy_username_entry.get_text() password = self._proxy_password_entry.get_text() else: username = None password = None proxy = ProxyString(url=url, username=username, password=password) self.proxy_url = proxy.url else: self.proxy_url = "" break else: # Ok clicked with invalid input, keep running the dialog continue else: # Cancel or Esc, just exit break self.window.destroy()
def refresh(self): GUIObject.refresh(self) if not self.proxy_url: self._proxy_check.set_active(False) self.on_proxy_enable_toggled(self._proxy_check) self._auth_check.set_active(False) self.on_proxy_auth_toggled(self._auth_check) return try: proxy = ProxyString(self.proxy_url) if proxy.username: self._proxy_username_entry.set_text(proxy.username) if proxy.password: self._proxy_password_entry.set_text(proxy.password) self._proxy_url_entry.set_text(proxy.noauth_url) except ProxyStringError as e: log.error("Failed to parse proxy for ProxyDialog.refresh %s: %s", self.proxy_url, e) return self._proxy_check.set_active(True) self._auth_check.set_active(bool(proxy.username or proxy.password)) self.on_proxy_enable_toggled(self._proxy_check) self.on_proxy_auth_toggled(self._auth_check)
def _setup_url_image(self): """ Check to make sure the url is available and estimate the space needed to download and install it. """ self._proxies = {} if self.data.liveimg.proxy: try: proxy = ProxyString(self.data.liveimg.proxy) self._proxies = {"http": proxy.url, "https": proxy.url} except ProxyStringError as e: log.info( "Failed to parse proxy for liveimg --proxy=\"%s\": %s", self.data.liveimg.proxy, e) error = None try: response = self._session.head(self.data.liveimg.url, proxies=self._proxies, verify=True, timeout=NETWORK_CONNECTION_TIMEOUT) # At this point we know we can get the image and what its size is # Make a guess as to minimum size needed: # Enough space for image and image * 3 if response.headers.get('content-length'): self._min_size = int( response.headers.get('content-length')) * 4 except IOError as e: log.error("Error opening liveimg: %s", e) error = e else: if response.status_code != 200: error = "http request returned %s" % response.status_code return error
def _validate_proxy(self, proxy): if not proxy: return try: ProxyString(url=proxy) except ProxyStringError as e: raise InvalidValueError("Proxy URL does not have valid format: {}".format(str(e))) \ from e
def get_proxies_from_option(proxy_option): proxies = {} if proxy_option: try: proxy = ProxyString(proxy_option) proxies = {"http": proxy.url, "https": proxy.url} except ProxyStringError as e: log.info("Failed to parse proxy \"%s\": %s", proxy_option, e) return proxies
def on_http_proxy_location_entry_changed(self, editable): hostname = "" port = -1 # not set == -1 entered_text = editable.get_text() if entered_text: proxy_obj = ProxyString(url=entered_text) hostname = proxy_obj.host if proxy_obj.port: # the DBus API expects an integer port = int(proxy_obj.port) self.subscription_request.server_proxy_hostname = hostname self.subscription_request.server_proxy_port = port
def _write_dnf_repo(self, repo, repo_path): """Write a repo object to a DNF repo.conf file. :param repo: DNF repository object :param string repo_path: Path to write the repo to :raises: PayloadSetupError if the repo doesn't have a url """ with open(repo_path, "w") as f: f.write("[%s]\n" % repo.id) f.write("name=%s\n" % repo.id) if self.is_repo_enabled(repo.id): f.write("enabled=1\n") else: f.write("enabled=0\n") if repo.mirrorlist: f.write("mirrorlist=%s\n" % repo.mirrorlist) elif repo.metalink: f.write("metalink=%s\n" % repo.metalink) elif repo.baseurl: f.write("baseurl=%s\n" % repo.baseurl[0]) else: f.close() os.unlink(repo_path) raise PayloadSetupError( "The repo {} has no baseurl, mirrorlist or " "metalink".format(repo.id)) # kickstart repo modifiers ks_repo = self.get_addon_repo(repo.id) if not ks_repo: return if ks_repo.noverifyssl: f.write("sslverify=0\n") if ks_repo.proxy: try: proxy = ProxyString(ks_repo.proxy) f.write("proxy=%s\n" % proxy.url) except ProxyStringError as e: log.error( "Failed to parse proxy for _writeInstallConfig %s: %s", ks_repo.proxy, e) if ks_repo.cost: f.write("cost=%d\n" % ks_repo.cost) if ks_repo.includepkgs: f.write("include=%s\n" % ",".join(ks_repo.includepkgs)) if ks_repo.excludepkgs: f.write("exclude=%s\n" % ",".join(ks_repo.excludepkgs))
def _refresh_install_tree(self, data: RepoConfigurationData): """Refresh installation tree metadata.""" if data.type != URL_TYPE_BASEURL: return if not data.url: return url = data.url proxy_url = data.proxy or None # ssl_verify can be: # - the path to a cert file # - True, to use the system's certificates # - False, to not verify ssl_verify = (data.ssl_configuration.ca_cert_path or (conf.payload.verify_ssl and data.ssl_verification_enabled)) ssl_client_cert = data.ssl_configuration.client_cert_path or None ssl_client_key = data.ssl_configuration.client_key_path or None ssl_cert = (ssl_client_cert, ssl_client_key) if ssl_client_cert else None log.debug("retrieving treeinfo from %s (proxy: %s ; ssl_verify: %s)", url, proxy_url, ssl_verify) proxies = {} if proxy_url: try: proxy = ProxyString(proxy_url) proxies = {"http": proxy.url, "https": proxy.url} except ProxyStringError as e: log.info("Failed to parse proxy for _getTreeInfo %s: %s", proxy_url, e) headers = {"user-agent": USER_AGENT} self._install_tree_metadata = InstallTreeMetadata() try: ret = self._install_tree_metadata.load_url(url, proxies, ssl_verify, ssl_cert, headers) except FileNotDownloadedError as e: self._install_tree_metadata = None self.verbose_errors.append(str(e)) log.warning("Install tree metadata fetching failed: %s", str(e)) return if not ret: log.warning("Install tree metadata can't be loaded!") self._install_tree_metadata = None
def _parse_proxy(self, url): """Parse the given proxy URL. :param url: a string with the proxy URL :return: an instance of ProxyString or None """ if not url: return None try: return ProxyString(url) except ProxyStringError as e: log.error("Failed to parse the proxy '%s': %s", url, e) return None
def _get_downloader(self, session, data): """Get a configured session.get method. :return: a partial function """ # Prepare the SSL configuration. ssl_enabled = conf.payload.verify_ssl and data.ssl_verification_enabled # ssl_verify can be: # - the path to a cert file # - True, to use the system's certificates # - False, to not verify ssl_verify = data.ssl_configuration.ca_cert_path or ssl_enabled # ssl_cert can be: # - a tuple of paths to a client cert file and a client key file # - None ssl_client_cert = data.ssl_configuration.client_cert_path or None ssl_client_key = data.ssl_configuration.client_key_path or None ssl_cert = (ssl_client_cert, ssl_client_key) if ssl_client_cert else None # Prepare the proxy configuration. proxy_url = data.proxy or None proxies = {} if proxy_url: try: proxy = ProxyString(proxy_url) proxies = { "http": proxy.url, "https": proxy.url } except ProxyStringError as e: log.debug("Failed to parse the proxy '%s': %s", proxy_url, e) # Prepare headers. headers = {"user-agent": USER_AGENT} # Return a partial function. return partial( session.get, headers=headers, proxies=proxies, verify=ssl_verify, cert=ssl_cert, timeout=NETWORK_CONNECTION_TIMEOUT )
def on_http_proxy_location_entry_changed(self, editable): # Incorrect hostnames, including empty strings, will # throw an exception we need to catch and switch # to defaults. This can happen often as the user # types the hostname to the field. try: port = -1 # not set == -1 proxy_obj = ProxyString(url=editable.get_text()) hostname = proxy_obj.host if proxy_obj.port: # the DBus API expects an integer port = int(proxy_obj.port) except ProxyStringError: hostname = "" # set the resulting values to the DBus structure self.subscription_request.server_proxy_hostname = hostname self.subscription_request.server_proxy_port = port
def _download_repoMD(self): proxies = {} repomd = "" headers = {"user-agent": USER_AGENT} if self._proxy_url is not None: try: proxy = ProxyString(self._proxy_url) proxies = {"http": proxy.url, "https": proxy.url} except ProxyStringError as e: log.info( "Failed to parse proxy for test if repo available %s: %s", self._proxy_url, e) session = util.requests_session() # Test all urls for this repo. If any of these is working it is enough. for url in self._urls: try: result = session.get( "%s/repodata/repomd.xml" % url, headers=headers, proxies=proxies, verify=self._ssl_verify, timeout=constants.NETWORK_CONNECTION_TIMEOUT) if result.ok: repomd = result.text result.close() break else: log.debug( "Server returned %i code when downloading repomd", result.status_code) result.close() continue except RequestException as e: log.debug( "Can't download new repomd.xml from %s with proxy: %s. Error: %s", url, proxies, e) return repomd
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))
if localization_proxy.KeyboardKickstarted: if conf.system.can_activate_keyboard: keyboard.activate_keyboard(localization_proxy) else: # at least make sure we have all the values keyboard.populate_missing_items(localization_proxy) # Some post-install parts of anaconda are implemented as kickstart # scripts. Add those to the ksdata now. kickstart.appendPostScripts(ksdata) if opts.proxy: # Setup proxy environmental variables so that pre/post scripts use it # as well as libreport try: proxy = ProxyString(opts.proxy) except ProxyStringError as e: log.info("Failed to parse proxy \"%s\": %s", opts.proxy, e) else: # Set environmental variables to be used by pre/post scripts util.setenv("PROXY", proxy.noauth_url) util.setenv("PROXY_USER", proxy.username or "") util.setenv("PROXY_PASSWORD", proxy.password or "") # Variables used by curl, libreport, etc. util.setenv("http_proxy", proxy.url) util.setenv("ftp_proxy", proxy.url) util.setenv("HTTPS_PROXY", proxy.url) # Set up the payload from the cmdline options. anaconda.payload.set_from_opts(opts)
def _add_repo_to_dnf(self, ksrepo): """Add a repo to the dnf repo object. :param ksrepo: Kickstart Repository to add :type ksrepo: Kickstart RepoData object. :returns: None """ repo = dnf.repo.Repo(ksrepo.name, self._base.conf) url = self._dnf_manager.substitute(ksrepo.baseurl) mirrorlist = self._dnf_manager.substitute(ksrepo.mirrorlist) metalink = self._dnf_manager.substitute(ksrepo.metalink) if url and url.startswith("nfs://"): (server, path) = url[6:].split(":", 1) # DNF is dynamically creating properties which seems confusing for Pylint here # pylint: disable=no-member mountpoint = "%s/%s.nfs" % (constants.MOUNT_DIR, repo.name) self._setup_NFS(mountpoint, server, path, None) url = "file://" + mountpoint if url: repo.baseurl = [url] if mirrorlist: repo.mirrorlist = mirrorlist if metalink: repo.metalink = metalink repo.sslverify = not ksrepo.noverifyssl and conf.payload.verify_ssl if ksrepo.proxy: try: repo.proxy = ProxyString(ksrepo.proxy).url except ProxyStringError as e: log.error("Failed to parse proxy for _add_repo %s: %s", ksrepo.proxy, e) if ksrepo.cost: repo.cost = ksrepo.cost if ksrepo.includepkgs: repo.include = ksrepo.includepkgs if ksrepo.excludepkgs: repo.exclude = ksrepo.excludepkgs if ksrepo.sslcacert: repo.sslcacert = ksrepo.sslcacert if ksrepo.sslclientcert: repo.sslclientcert = ksrepo.sslclientcert if ksrepo.sslclientkey: repo.sslclientkey = ksrepo.sslclientkey # If this repo is already known, it's one of two things: # (1) The user is trying to do "repo --name=updates" in a kickstart file # and we should just know to enable the already existing on-disk # repo config. # (2) It's a duplicate, and we need to delete the existing definition # and use this new one. The highest profile user of this is livecd # kickstarts. if repo.id in self._base.repos: if not url and not mirrorlist and not metalink: self._base.repos[repo.id].enable() else: with self._repos_lock: self._base.repos.pop(repo.id) self._base.repos.add(repo) # If the repo's not already known, we've got to add it. else: with self._repos_lock: self._base.repos.add(repo) if not ksrepo.enabled: self._disable_repo(repo.id) log.info("added repo: '%s' - %s", ksrepo.name, url or mirrorlist or metalink)