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.method.proxy:
try:
proxy = ProxyString(self.data.method.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.method.proxy, e)
error = None
try:
response = self._session.get(self.data.method.url,
proxies=self._proxies,
verify=True)
# 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)))
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 _refresh_install_tree(self, url):
"""Refresh installation tree metadata.
:param url: url of the repo
:type url: string
"""
if not url:
return
if hasattr(self.data.method, "proxy"):
proxy_url = self.data.method.proxy
else:
proxy_url = None
# ssl_verify can be:
# - the path to a cert file
# - True, to use the system's certificates
# - False, to not verify
ssl_verify = getattr(self.data.method, "sslcacert",
None) or conf.payload.verify_ssl
ssl_client_cert = getattr(self.data.method, "ssl_client_cert", None)
ssl_client_key = getattr(self.data.method, "ssl_client_key", 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 IOError 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 _writeDNFRepo(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.isRepoEnabled(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 payload.PayloadSetupError(
"repo %s has no baseurl, mirrorlist or metalink", repo.id)
# kickstart repo modifiers
ks_repo = self.getAddOnRepo(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 _configure_proxy(self):
"""Configure the proxy on the dnf.Base object."""
conf = self._base.conf
if hasattr(self.data.method, "proxy") and self.data.method.proxy:
try:
proxy = ProxyString(self.data.method.proxy)
conf.proxy = proxy.noauth_url
if proxy.username:
conf.proxy_username = proxy.username
if proxy.password:
conf.proxy_password = proxy.password
log.info("Using %s as proxy", self.data.method.proxy)
except ProxyStringError as e:
log.error("Failed to parse proxy for dnf configure %s: %s",
self.data.method.proxy, e)
else:
# No proxy configured
conf.proxy = None
conf.proxy_username = None
conf.proxy_password = None
def _download_repoMD(self, method):
proxies = {}
repomd = ""
headers = {"user-agent": USER_AGENT}
if hasattr(method, "proxy"):
proxy_url = method.proxy
try:
proxy = ProxyString(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",
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
break
else:
log.debug(
"Server returned %i code when downloading repomd",
result.status_code)
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 _add_repo(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._replace_vars(ksrepo.baseurl)
mirrorlist = self._replace_vars(ksrepo.mirrorlist)
metalink = self._replace_vars(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._setupNFS(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 or flags.noverifyssl)
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 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)
repo.enable()
# If the repo's not already known, we've got to add it.
else:
with self._repos_lock:
self._base.repos.add(repo)
repo.enable()
# Load the metadata to verify that the repo is valid
try:
self._base.repos[repo.id].load()
except dnf.exceptions.RepoError as e:
raise payload.MetadataError(e)
log.info("added repo: '%s' - %s", ksrepo.name, url or mirrorlist
or metalink)
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)
# cmdline flags override kickstart settings
if anaconda.proxy:
if hasattr(ksdata.method, "proxy"):
ksdata.method.proxy = anaconda.proxy
# Setup proxy environmental variables so that pre/post scripts use it
# as well as libreport
try:
proxy = ProxyString(anaconda.proxy)
except ProxyStringError as e:
log.info("Failed to parse proxy \"%s\": %s", anaconda.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)
if not conf.payload.verify_ssl and hasattr(ksdata.method, "noverifyssl"):
ksdata.method.noverifyssl = not conf.payload.verify_ssl
