def test_acquire(self):
apt_pkg.AcquireFile(apt_pkg.Acquire(), "http://example.com",
destdir=self.file_bytes, destfile=self.file_bytes)
apt_pkg.AcquireFile(apt_pkg.Acquire(),
"http://example.com",
destdir=self.file_unicode,
destfile=self.file_unicode)
def fetch_binary(self, destdir='', progress=None):
"""Fetch the binary version of the package.
The parameter *destdir* specifies the directory where the package will
be fetched to.
The parameter *progress* may refer to an apt_pkg.AcquireProgress()
object. If not specified or None, apt.progress.text.AcquireProgress()
is used.
.. versionadded:: 0.7.10
"""
base = os.path.basename(self._records.filename)
destfile = os.path.join(destdir, base)
if _file_is_same(destfile, self.size, self._records.md5_hash):
print('Ignoring already existing file: %s' % destfile)
return os.path.abspath(destfile)
acq = apt_pkg.Acquire(progress or apt.progress.text.AcquireProgress())
acqfile = apt_pkg.AcquireFile(acq,
self.uri,
self._records.md5_hash,
self.size,
base,
destfile=destfile)
acq.run()
if acqfile.status != acqfile.STAT_DONE:
raise FetchError("The item %r could not be fetched: %s" %
(acqfile.destfile, acqfile.error_text))
return os.path.abspath(destfile)
def fetch_source(self, destdir="", progress=None, unpack=True):
"""Get the source code of a package.
The parameter *destdir* specifies the directory where the source will
be fetched to.
The parameter *progress* may refer to an apt_pkg.AcquireProgress()
object. If not specified or None, apt.progress.text.AcquireProgress()
is used.
The parameter *unpack* describes whether the source should be unpacked
(``True``) or not (``False``). By default, it is unpacked.
If *unpack* is ``True``, the path to the extracted directory is
returned. Otherwise, the path to the .dsc file is returned.
"""
src = apt_pkg.SourceRecords()
acq = apt_pkg.Acquire(progress or apt.progress.text.AcquireProgress())
dsc = None
record = self._records
source_name = record.source_pkg or self.package.shortname
source_version = record.source_ver or self._cand.ver_str
source_lookup = src.lookup(source_name)
while source_lookup and source_version != src.version:
source_lookup = src.lookup(source_name)
if not source_lookup:
raise ValueError("No source for %r" % self)
files = list()
for md5, size, path, type_ in src.files:
base = os.path.basename(path)
destfile = os.path.join(destdir, base)
if type_ == 'dsc':
dsc = destfile
if _file_is_same(destfile, size, md5):
print('Ignoring already existing file: %s' % destfile)
continue
files.append(
apt_pkg.AcquireFile(acq,
src.index.archive_uri(path),
md5,
size,
base,
destfile=destfile))
acq.run()
for item in acq.items:
if item.status != item.STAT_DONE:
raise FetchError("The item %r could not be fetched: %s" %
(item.destfile, item.error_text))
if unpack:
outdir = src.package + '-' + apt_pkg.upstream_version(src.version)
outdir = os.path.join(destdir, outdir)
subprocess.check_call(["dpkg-source", "-x", dsc, outdir])
return os.path.abspath(outdir)
else:
return os.path.abspath(dsc)
def f_getpkg(pkg):
if not path.isdir(aptdir):
mkdir(aptdir)
p = apt.progress.text.AcquireProgress()
c = apt.Cache()
u = c[pkg].candidate.uri
a = apt_pkg.Acquire(p)
acq = apt_pkg.AcquireFile(a, uri=u, destdir=aptdir)
a.run()
def get_file(fetcher, uri, destfile):
# get the file
af = apt_pkg.AcquireFile(fetcher, uri=uri, descr="sample descr",
destfile=destfile)
print "desc_uri: %s -> %s" % (af.desc_uri, af.destfile)
res = fetcher.run()
if res != fetcher.RESULT_CONTINUE:
return False
return True
def test_acquire_hashes(self):
hs = apt_pkg.HashString("d41d8cd98f00b204e9800998ecf8427e")
hsl = apt_pkg.HashStringList()
hsl.append(hs)
apt_pkg.AcquireFile(apt_pkg.Acquire(),
"http://example.com",
hash=hsl,
destdir=self.file_unicode,
destfile=self.file_unicode)
apt_pkg.AcquireFile(apt_pkg.Acquire(),
"http://example.com",
hash=str(hs),
destdir=self.file_unicode,
destfile=self.file_unicode)
self.assertRaises(TypeError, apt_pkg.AcquireFile, apt_pkg.Acquire(),
"http://example.com",
hash=hs,
destdir=self.file_unicode,
destfile=self.file_unicode)
def get_file(fetcher, uri, destfile):
# get the file
af = apt_pkg.AcquireFile(fetcher,
uri=uri,
descr="sample descr",
destfile=destfile)
res = fetcher.Run()
if res != fetcher.ResultContinue:
return False
return True
def fetchDistUpgrader(self):
" download the tarball with the upgrade script "
tmpdir = tempfile.mkdtemp(prefix="ubuntu-release-upgrader-")
self.tmpdir = tmpdir
os.chdir(tmpdir)
logging.debug("using tmpdir: '%s'" % tmpdir)
# turn debugging on here (if required)
if self.DEBUG > 0:
apt_pkg.config.set("Debug::Acquire::http", "1")
apt_pkg.config.set("Debug::Acquire::ftp", "1")
#os.listdir(tmpdir)
fetcher = apt_pkg.Acquire(self._progress)
if self.new_dist.upgradeToolSig is not None:
uri = self._expandUri(self.new_dist.upgradeToolSig)
af1 = apt_pkg.AcquireFile(fetcher,
uri,
descr=_("Upgrade tool signature"))
# reference it here to shut pyflakes up
af1
if self.new_dist.upgradeTool is not None:
self.uri = self._expandUri(self.new_dist.upgradeTool)
af2 = apt_pkg.AcquireFile(fetcher,
self.uri,
descr=_("Upgrade tool"))
# reference it here to shut pyflakes up
af2
result = fetcher.run()
if result != fetcher.RESULT_CONTINUE:
logging.warn("fetch result != continue (%s)" % result)
return False
# check that both files are really there and non-null
for f in [
os.path.basename(self.new_dist.upgradeToolSig),
os.path.basename(self.new_dist.upgradeTool)
]:
if not (os.path.exists(f) and os.path.getsize(f) > 0):
logging.warn("file '%s' missing" % f)
return False
return True
return False
def test_acquire_file_md5_keyword_backward_compat(self):
"""
Ensure that both "md5" and "hash" is supported as keyword for
AcquireFile
"""
with warnings.catch_warnings(record=True) as caught_warnings:
warnings.simplefilter("always")
apt_pkg.AcquireFile(apt_pkg.Acquire(),
"http://example.com",
destfile=self.file_bytes,
md5="abcdef")
self.assertEqual(len(caught_warnings), 1)
self.assertTrue(
issubclass(caught_warnings[0].category, DeprecationWarning))
self.assertIn("md5", str(caught_warnings[0].message))
self.assertIn("hash", str(caught_warnings[0].message))
apt_pkg.AcquireFile(
apt_pkg.Acquire(),
"http://example.com",
destfile=self.file_bytes,
hash="sha1:41050ed528554fdd6c6c9a086ddd6bdba5857b21")
def fetch_binary(version, destdir='', progress=None):
# type: (str, AcquireProgress) -> str
"""Fetch the binary version of the package.
The parameter *destdir* specifies the directory where the package will
be fetched to.
The parameter *progress* may refer to an apt_pkg.AcquireProgress()
object. If not specified or None, apt.progress.text.AcquireProgress()
is used.
taken from python-apt-1.8.4
https://salsa.debian.org/apt-team/python-apt/-/blob/1.8.4/apt/package.py
---------------------------------------------------------
Copyright (c) 2005-2009 Canonical
Author: Michael Vogt <*****@*****.**>
---------------------------------------------------------
Then fixed up to use sha256 and pass pycodestyle.
"""
# pylint: disable=protected-access
base = os.path.basename(version._records.filename)
destfile = os.path.join(destdir, base)
# pylint: disable=protected-access
if _file_is_same(destfile, version.size, version._records.sha256_hash):
logging.debug('Ignoring already existing file: %s', destfile)
return os.path.abspath(destfile)
acq = apt_pkg.Acquire(progress or apt.progress.text.AcquireProgress())
# pylint: disable=protected-access
acqfile = apt_pkg.AcquireFile(acq,
version.uri,
"SHA256:" + version._records.sha256_hash,
version.size,
base,
destfile=destfile)
acq.run()
if acqfile.status != acqfile.STAT_DONE:
raise FetchError("The item %r could not be fetched: %s" %
(acqfile.destfile, acqfile.error_text))
return os.path.abspath(destfile)
def mark_pkg_download(self, pkgname):
pkg = self.cache[pkgname]
c = self.depcache.get_candidate_ver(pkg)
r = apt_pkg.PackageRecords(self.cache)
r.lookup(c.file_list[0])
x = self.source.find_index(c.file_list[0][0])
uri = x.archive_uri(r.filename)
hashval = str(r.hashes.find('SHA256'))
acq = apt_pkg.AcquireFile(self.acquire,
uri,
hash=hashval,
size=c.size,
descr=r.long_desc,
short_descr=r.short_desc,
destdir=self.basefs.fname('/cache/archives'))
self.downloads[pkgname] = acq
def fetch_packages(self, packages, download_content=True):
"""Fetch the files for the given list of package names.
The files, and all their dependencies are download, and the metadata
and content returned as FetchedPackage objects.
If download_content is False then only the metadata is returned
(i.e. the FetchedPackages will have None for their content
attribute), and only information about the specified packages
will be returned, no dependencies.
No packages that have been ignored, or are recursive dependencies
of ignored packages will be returned.
:param packages: a list of package names to install
:type packages: an iterable of str
:param download_content: whether to download the content of the
packages. Default is to do so.
:type download_content: bool
:return: a list of the packages that were fetched, with relevant
metdata and the contents of the files available.
:rtype: an iterable of FetchedPackages.
:raises KeyError: if any of the package names in the list couldn't
be found.
"""
fetched = {}
for package in packages:
candidate = self.cache.cache[package].candidate
base = os.path.basename(candidate.filename)
result_package = FetchedPackage.from_apt(candidate, base)
fetched[package] = result_package
def check_no_broken_packages():
if self.cache.cache.broken_count:
raise DependencyNotSatisfied(
"Unable to satisfy dependencies of %s" % ", ".join(
[p.name
for p in self.cache.cache if p.is_inst_broken]))
for package in packages:
try:
self.cache.cache[package].mark_install(auto_fix=True)
except SystemError:
# Either we raise a DependencyNotSatisfied error
# if some packages are broken, or we raise the original
# error if there was another cause
check_no_broken_packages()
raise
# Check that nothing was broken, even if mark_install didn't
# raise SystemError, just to make sure.
check_no_broken_packages()
self._filter_ignored(fetched)
if not download_content:
self.cache.cache.clear()
return fetched.values()
acq = apt_pkg.Acquire(DummyProgress())
acqfiles = []
# re to remove the repo private key
deb_url_auth_re = re.compile(
r"(?P<transport>.*://)(?P<user>.*):.*@(?P<path>.*$)")
for package in self.cache.cache.get_changes():
if (package.marked_delete or package.marked_keep):
continue
logger.debug("Fetching %s ..." % package)
candidate = package.candidate
base = os.path.basename(candidate.filename)
if package.name not in fetched:
result_package = FetchedPackage.from_apt(candidate, base)
fetched[package.name] = result_package
result_package = fetched[package.name]
destfile = os.path.join(self.cache.tempdir, base)
acqfile = apt_pkg.AcquireFile(acq,
candidate.uri,
candidate.md5,
candidate.size,
base,
destfile=destfile)
acqfiles.append((acqfile, result_package, destfile))
# check if we have a private key in the pkg url
deb_url_auth = deb_url_auth_re.match(acqfile.desc_uri)
if deb_url_auth:
logger.debug(" ... from %s%s:***@%s" % deb_url_auth.groups())
else:
logger.debug(" ... from %s" % acqfile.desc_uri)
self.cache.cache.clear()
acq.run()
for acqfile, result_package, destfile in acqfiles:
if acqfile.status != acqfile.STAT_DONE:
raise FetchError("The item %r could not be fetched: %s" %
(acqfile.destfile, acqfile.error_text))
result_package.content = open(destfile)
result_package._file_path = destfile
return fetched.values()
