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)