def delete_count(self):
"""Return the number of packages marked for deletion."""
return self._depcache.del_count
@property
def install_count(self):
"""Return the number of packages marked for installation."""
return self._depcache.inst_count
@property
def keep_count(self):
"""Return the number of packages marked as keep."""
return self._depcache.keep_count
if apt_pkg._COMPAT_0_7:
_runCallbacks = function_deprecated_by(_run_callbacks)
getChanges = function_deprecated_by(get_changes)
requiredDownload = AttributeDeprecatedBy('required_download')
additionalRequiredSpace = AttributeDeprecatedBy('required_space')
reqReinstallPkgs = AttributeDeprecatedBy('req_reinstall_pkgs')
_runFetcher = function_deprecated_by(_run_fetcher)
_fetchArchives = function_deprecated_by(_fetch_archives)
isVirtualPackage = function_deprecated_by(is_virtual_package)
getProvidingPackages = function_deprecated_by(get_providing_packages)
installArchives = function_deprecated_by(install_archives)
cachePostChange = function_deprecated_by(cache_post_change)
cachePreChange = function_deprecated_by(cache_pre_change)
class ProblemResolver(object):
"""Resolve problems due to dependencies and conflicts.
class Package(object):
"""Representation of a package in a cache.
This class provides methods and properties for working with a package. It
lets you mark the package for installation, check if it is installed, and
much more.
"""
def __init__(self, pcache, pkgiter):
""" Init the Package object """
self._pkg = pkgiter
self._pcache = pcache # python cache in cache.py
self._changelog = "" # Cached changelog
def __repr__(self):
return '<Package: name:%r architecture=%r id:%r>' % (
self._pkg.name, self._pkg.architecture, self._pkg.id)
def __lt__(self, other):
return self.name < other.name
def candidate(self):
"""Return the candidate version of the package.
This property is writeable to allow you to set the candidate version
of the package. Just assign a Version() object, and it will be set as
the candidate version.
"""
cand = self._pcache._depcache.get_candidate_ver(self._pkg)
if cand is not None:
return Version(self, cand)
def __set_candidate(self, version):
"""Set the candidate version of the package."""
self._pcache.cache_pre_change()
self._pcache._depcache.set_candidate_ver(self._pkg, version._cand)
self._pcache.cache_post_change()
candidate = property(candidate, __set_candidate)
@property
def installed(self):
"""Return the currently installed version of the package.
.. versionadded:: 0.7.9
"""
if self._pkg.current_ver is not None:
return Version(self, self._pkg.current_ver)
@property
def name(self):
"""Return the name of the package, possibly including architecture.
If the package is not part of the system's preferred architecture,
return the same as :attr:`fullname`, otherwise return the same
as :attr:`shortname`
.. versionchanged:: 0.7.100.3
As part of multi-arch, this field now may include architecture
information.
"""
return self._pkg.get_fullname(True)
@property
def fullname(self):
"""Return the name of the package, including architecture.
.. versionadded:: 0.7.100.3"""
return self._pkg.get_fullname(False)
@property
def shortname(self):
"""Return the name of the package, without architecture.
.. versionadded:: 0.7.100.3"""
return self._pkg.name
@property
def id(self):
"""Return a uniq ID for the package.
This can be used eg. to store additional information about the pkg."""
return self._pkg.id
def __hash__(self):
"""Return the hash of the object.
This returns the same value as ID, which is unique."""
return self._pkg.id
@property
def essential(self):
"""Return True if the package is an essential part of the system."""
return self._pkg.essential
@DeprecatedProperty
def installedVersion(self): #pylint: disable-msg=C0103
"""Return the installed version as string.
.. deprecated:: 0.7.9"""
return getattr(self.installed, 'version', None)
@DeprecatedProperty
def candidateVersion(self): #pylint: disable-msg=C0103
"""Return the candidate version as string.
.. deprecated:: 0.7.9"""
return getattr(self.candidate, "version", None)
@DeprecatedProperty
def candidateDependencies(self): #pylint: disable-msg=C0103
"""Return a list of candidate dependencies.
.. deprecated:: 0.7.9
"""
return getattr(self.candidate, "dependencies", None)
@DeprecatedProperty
def installedDependencies(self): #pylint: disable-msg=C0103
"""Return a list of installed dependencies.
.. deprecated:: 0.7.9
"""
return getattr(self.installed, 'dependencies', [])
def architecture(self):
"""Return the Architecture of the package.
.. versionchanged:: 0.7.100.3
This is now the package's architecture in the multi-arch sense,
previously it was the architecture of the candidate version
and deprecated.
"""
return self._pkg.architecture
@DeprecatedProperty
def candidateDownloadable(self): #pylint: disable-msg=C0103
"""Return ``True`` if the candidate is downloadable.
.. deprecated:: 0.7.9
"""
return getattr(self.candidate, "downloadable", None)
@DeprecatedProperty
def installedDownloadable(self): #pylint: disable-msg=C0103
"""Return ``True`` if the installed version is downloadable.
.. deprecated:: 0.7.9
"""
return getattr(self.installed, 'downloadable', False)
@DeprecatedProperty
def sourcePackageName(self): #pylint: disable-msg=C0103
"""Return the source package name as string.
.. deprecated:: 0.7.9
"""
try:
return self.candidate._records.source_pkg or self._pkg.name
except AttributeError:
try:
return self.installed._records.source_pkg or self._pkg.name
except AttributeError:
return self._pkg.name
@DeprecatedProperty
def homepage(self):
"""Return the homepage field as string.
.. deprecated:: 0.7.9
"""
return getattr(self.candidate, "homepage", None)
@property
def section(self):
"""Return the section of the package."""
return self._pkg.section
@DeprecatedProperty
def priority(self):
"""Return the priority (of the candidate version).
.. deprecated:: 0.7.9
"""
return getattr(self.candidate, "priority", None)
@DeprecatedProperty
def installedPriority(self): #pylint: disable-msg=C0103
"""Return the priority (of the installed version).
.. deprecated:: 0.7.9
"""
return getattr(self.installed, 'priority', None)
@DeprecatedProperty
def summary(self):
"""Return the short description (one line summary).
.. deprecated:: 0.7.9
"""
return getattr(self.candidate, "summary", None)
@DeprecatedProperty
def description(self):
"""Return the formatted long description.
Return the formatted long description according to the Debian policy
(Chapter 5.6.13).
See http://www.debian.org/doc/debian-policy/ch-controlfields.html
for more information.
.. deprecated:: 0.7.9
"""
return getattr(self.candidate, "description", None)
@DeprecatedProperty
def rawDescription(self): #pylint: disable-msg=C0103
"""return the long description (raw).
.. deprecated:: 0.7.9"""
return getattr(self.candidate, "raw_description", None)
@DeprecatedProperty
def candidateRecord(self): #pylint: disable-msg=C0103
"""Return the Record of the candidate version of the package.
.. deprecated:: 0.7.9"""
return getattr(self.candidate, "record", None)
@DeprecatedProperty
def installedRecord(self): #pylint: disable-msg=C0103
"""Return the Record of the candidate version of the package.
.. deprecated:: 0.7.9"""
return getattr(self.installed, 'record', '')
# depcache states
@property
def marked_install(self):
"""Return ``True`` if the package is marked for install."""
return self._pcache._depcache.marked_install(self._pkg)
@property
def marked_upgrade(self):
"""Return ``True`` if the package is marked for upgrade."""
return self._pcache._depcache.marked_upgrade(self._pkg)
@property
def marked_delete(self):
"""Return ``True`` if the package is marked for delete."""
return self._pcache._depcache.marked_delete(self._pkg)
@property
def marked_keep(self):
"""Return ``True`` if the package is marked for keep."""
return self._pcache._depcache.marked_keep(self._pkg)
@property
def marked_downgrade(self):
""" Package is marked for downgrade """
return self._pcache._depcache.marked_downgrade(self._pkg)
@property
def marked_reinstall(self):
"""Return ``True`` if the package is marked for reinstall."""
return self._pcache._depcache.marked_reinstall(self._pkg)
@property
def is_installed(self):
"""Return ``True`` if the package is installed."""
return (self._pkg.current_ver is not None)
@property
def is_upgradable(self):
"""Return ``True`` if the package is upgradable."""
return (self.is_installed
and self._pcache._depcache.is_upgradable(self._pkg))
@property
def is_auto_removable(self):
"""Return ``True`` if the package is no longer required.
If the package has been installed automatically as a dependency of
another package, and if no packages depend on it anymore, the package
is no longer required.
"""
return ((self.is_installed or self.marked_install)
and self._pcache._depcache.is_garbage(self._pkg))
@property
def is_auto_installed(self):
"""Return whether the package is marked as automatically installed."""
return self._pcache._depcache.is_auto_installed(self._pkg)
# sizes
@DeprecatedProperty
def packageSize(self): #pylint: disable-msg=C0103
"""Return the size of the candidate deb package.
.. deprecated:: 0.7.9
"""
return getattr(self.candidate, "size", None)
@DeprecatedProperty
def installedPackageSize(self): #pylint: disable-msg=C0103
"""Return the size of the installed deb package.
.. deprecated:: 0.7.9
"""
return getattr(self.installed, 'size', 0)
@DeprecatedProperty
def candidateInstalledSize(self): #pylint: disable-msg=C0103
"""Return the size of the candidate installed package.
.. deprecated:: 0.7.9
"""
return getattr(self.candidate, "installed_size", None)
@DeprecatedProperty
def installedSize(self): #pylint: disable-msg=C0103
"""Return the size of the currently installed package.
.. deprecated:: 0.7.9
"""
return getattr(self.installed, 'installed_size', 0)
@property
def installed_files(self):
"""Return a list of files installed by the package.
Return a list of unicode names of the files which have
been installed by this package
"""
for name in self.shortname, self.fullname:
path = "/var/lib/dpkg/info/%s.list" % name
try:
with open(path, "rb") as file_list:
return file_list.read().decode("utf-8").split(u"\n")
except EnvironmentError:
continue
return []
def get_changelog(self, uri=None, cancel_lock=None):
"""
Download the changelog of the package and return it as unicode
string.
The parameter *uri* refers to the uri of the changelog file. It may
contain multiple named variables which will be substitued. These
variables are (src_section, prefix, src_pkg, src_ver). An example is
the Ubuntu changelog::
"http://changelogs.ubuntu.com/changelogs/pool" \\
"/%(src_section)s/%(prefix)s/%(src_pkg)s" \\
"/%(src_pkg)s_%(src_ver)s/changelog"
The parameter *cancel_lock* refers to an instance of threading.Lock,
which if set, prevents the download.
"""
# Return a cached changelog if available
if self._changelog != u"":
return self._changelog
if uri is None:
if not self.candidate:
pass
if self.candidate.origins[0].origin == "Debian":
uri = "http://packages.debian.org/changelogs/pool" \
"/%(src_section)s/%(prefix)s/%(src_pkg)s" \
"/%(src_pkg)s_%(src_ver)s/changelog"
elif self.candidate.origins[0].origin == "Ubuntu":
uri = "http://changelogs.ubuntu.com/changelogs/pool" \
"/%(src_section)s/%(prefix)s/%(src_pkg)s" \
"/%(src_pkg)s_%(src_ver)s/changelog"
else:
res = _("The list of changes is not available")
return res if isinstance(res, unicode) else res.decode("utf-8")
# get the src package name
src_pkg = self.candidate.source_name
# assume "main" section
src_section = "main"
# use the section of the candidate as a starting point
section = self.candidate.section
# get the source version
src_ver = self.candidate.source_version
try:
# try to get the source version of the pkg, this differs
# for some (e.g. libnspr4 on ubuntu)
# this feature only works if the correct deb-src are in the
# sources.list otherwise we fall back to the binary version number
src_records = apt_pkg.SourceRecords()
except SystemError:
pass
else:
while src_records.lookup(src_pkg):
if not src_records.version:
continue
if self.candidate.source_version == src_records.version:
# Direct match, use it and do not do more lookups.
src_ver = src_records.version
section = src_records.section
break
if apt_pkg.version_compare(src_records.version, src_ver) > 0:
# The version is higher, it seems to match.
src_ver = src_records.version
section = src_records.section
section_split = section.split("/", 1)
if len(section_split) > 1:
src_section = section_split[0]
del section_split
# lib is handled special
prefix = src_pkg[0]
if src_pkg.startswith("lib"):
prefix = "lib" + src_pkg[3]
# stip epoch
src_ver_split = src_ver.split(":", 1)
if len(src_ver_split) > 1:
src_ver = "".join(src_ver_split[1:])
del src_ver_split
uri = uri % {
"src_section": src_section,
"prefix": prefix,
"src_pkg": src_pkg,
"src_ver": src_ver
}
timeout = socket.getdefaulttimeout()
# FIXME: when python2.4 vanishes from the archive,
# merge this into a single try..finally block (pep 341)
try:
try:
# Set a timeout for the changelog download
socket.setdefaulttimeout(2)
# Check if the download was canceled
if cancel_lock and cancel_lock.isSet():
return u""
# FIXME: python3.2: Should be closed manually
changelog_file = urllib2.urlopen(uri)
# do only get the lines that are new
changelog = u""
regexp = "^%s \((.*)\)(.*)$" % (re.escape(src_pkg))
while True:
# Check if the download was canceled
if cancel_lock and cancel_lock.isSet():
return u""
# Read changelog line by line
line_raw = changelog_file.readline()
if not line_raw:
break
# The changelog is encoded in utf-8, but since there isn't
# any http header, urllib2 seems to treat it as ascii
line = line_raw.decode("utf-8")
#print line.encode('utf-8')
match = re.match(regexp, line)
if match:
# strip epoch from installed version
# and from changelog too
installed = getattr(self.installed, 'version', None)
if installed and ":" in installed:
installed = installed.split(":", 1)[1]
changelog_ver = match.group(1)
if changelog_ver and ":" in changelog_ver:
changelog_ver = changelog_ver.split(":", 1)[1]
if (installed and apt_pkg.version_compare(
changelog_ver, installed) <= 0):
break
# EOF (shouldn't really happen)
changelog += line
# Print an error if we failed to extract a changelog
if len(changelog) == 0:
changelog = _("The list of changes is not available")
if not isinstance(changelog, unicode):
changelog = changelog.decode("utf-8")
self._changelog = changelog
except urllib2.HTTPError:
res = _("The list of changes is not available yet.\n\n"
"Please use http://launchpad.net/ubuntu/+source/%s/"
"%s/+changelog\n"
"until the changes become available or try again "
"later.") % (src_pkg, src_ver)
return res if isinstance(res, unicode) else res.decode("utf-8")
except (IOError, httplib.BadStatusLine):
res = _("Failed to download the list of changes. \nPlease "
"check your Internet connection.")
return res if isinstance(res, unicode) else res.decode("utf-8")
finally:
socket.setdefaulttimeout(timeout)
return self._changelog
@DeprecatedProperty
def candidateOrigin(self): #pylint: disable-msg=C0103
"""Return a list of `Origin()` objects for the candidate version.
.. deprecated:: 0.7.9
"""
return getattr(self.candidate, "origins", None)
@property
def versions(self):
"""Return a VersionList() object for all available versions.
.. versionadded:: 0.7.9
"""
return VersionList(self)
@property
def is_inst_broken(self):
"""Return True if the to-be-installed package is broken."""
return self._pcache._depcache.is_inst_broken(self._pkg)
@property
def is_now_broken(self):
"""Return True if the installed package is broken."""
return self._pcache._depcache.is_now_broken(self._pkg)
# depcache actions
def mark_keep(self):
"""Mark a package for keep."""
self._pcache.cache_pre_change()
self._pcache._depcache.mark_keep(self._pkg)
self._pcache.cache_post_change()
@deprecated_args
def mark_delete(self, auto_fix=True, purge=False):
"""Mark a package for deletion.
If *auto_fix* is ``True``, the resolver will be run, trying to fix
broken packages. This is the default.
If *purge* is ``True``, remove the configuration files of the package
as well. The default is to keep the configuration.
"""
self._pcache.cache_pre_change()
self._pcache._depcache.mark_delete(self._pkg, purge)
# try to fix broken stuffsta
if auto_fix and self._pcache._depcache.broken_count > 0:
fix = apt_pkg.ProblemResolver(self._pcache._depcache)
fix.clear(self._pkg)
fix.protect(self._pkg)
fix.remove(self._pkg)
fix.install_protect()
fix.resolve()
self._pcache.cache_post_change()
@deprecated_args
def mark_install(self, auto_fix=True, auto_inst=True, from_user=True):
"""Mark a package for install.
If *autoFix* is ``True``, the resolver will be run, trying to fix
broken packages. This is the default.
If *autoInst* is ``True``, the dependencies of the packages will be
installed automatically. This is the default.
If *fromUser* is ``True``, this package will not be marked as
automatically installed. This is the default. Set it to False if you
want to be able to automatically remove the package at a later stage
when no other package depends on it.
"""
self._pcache.cache_pre_change()
self._pcache._depcache.mark_install(self._pkg, auto_inst, from_user)
# try to fix broken stuff
if auto_fix and self._pcache._depcache.broken_count > 0:
fixer = apt_pkg.ProblemResolver(self._pcache._depcache)
fixer.clear(self._pkg)
fixer.protect(self._pkg)
fixer.resolve(True)
self._pcache.cache_post_change()
def mark_upgrade(self):
"""Mark a package for upgrade."""
if self.is_upgradable:
from_user = not self._pcache._depcache.is_auto_installed(self._pkg)
self.mark_install(from_user=from_user)
else:
# FIXME: we may want to throw a exception here
sys.stderr.write(("MarkUpgrade() called on a non-upgrable pkg: "
"'%s'\n") % self._pkg.name)
def mark_auto(self, auto=True):
"""Mark a package as automatically installed.
Call this function to mark a package as automatically installed. If the
optional parameter *auto* is set to ``False``, the package will not be
marked as automatically installed anymore. The default is ``True``.
"""
self._pcache._depcache.mark_auto(self._pkg, auto)
def commit(self, fprogress, iprogress):
"""Commit the changes.
The parameter *fprogress* refers to a apt_pkg.AcquireProgress() object,
like apt.progress.text.AcquireProgress().
The parameter *iprogress* refers to an InstallProgress() object, as
found in apt.progress.base.
"""
self._pcache._depcache.commit(fprogress, iprogress)
if not apt_pkg._COMPAT_0_7:
del installedVersion
del candidateVersion
del candidateDependencies
del installedDependencies
del architecture
del candidateDownloadable
del installedDownloadable
del sourcePackageName
del homepage
del priority
del installedPriority
del summary
del description
del rawDescription
del candidateRecord
del installedRecord
del packageSize
del installedPackageSize
del candidateInstalledSize
del installedSize
del candidateOrigin
else:
markedInstalled = AttributeDeprecatedBy('marked_installed')
markedInstall = AttributeDeprecatedBy('marked_install')
markedUpgrade = AttributeDeprecatedBy('marked_upgrade')
markedDelete = AttributeDeprecatedBy('marked_delete')
markedKeep = AttributeDeprecatedBy('marked_keep')
markedDowngrade = AttributeDeprecatedBy('marked_downgrade')
markedReinstall = AttributeDeprecatedBy('marked_reinstall')
isInstalled = AttributeDeprecatedBy('is_installed')
isUpgradable = AttributeDeprecatedBy('is_upgradable')
isAutoRemovable = AttributeDeprecatedBy('is_auto_removable')
installedFiles = AttributeDeprecatedBy('installed_files')
getChangelog = function_deprecated_by(get_changelog)
markDelete = function_deprecated_by(mark_delete)
markInstall = function_deprecated_by(mark_install)
markKeep = function_deprecated_by(mark_keep)
markUpgrade = function_deprecated_by(mark_upgrade)
class SourcesList(object):
""" represents the full sources.list + sources.list.d file """
def __init__(self,
withMatcher=True,
matcherPath="/usr/share/python-apt/templates/"):
self.list = [] # the actual SourceEntries Type
if withMatcher:
self.matcher = SourceEntryMatcher(matcherPath)
else:
self.matcher = NullMatcher()
self.refresh()
def refresh(self):
""" update the list of known entries """
self.list = []
# read sources.list
file = apt_pkg.config.find_file("Dir::Etc::sourcelist")
self.load(file)
# read sources.list.d
partsdir = apt_pkg.config.find_dir("Dir::Etc::sourceparts")
for file in glob.glob("%s/*.list" % partsdir):
self.load(file)
# check if the source item fits a predefined template
for source in self.list:
if not source.invalid:
self.matcher.match(source)
def __iter__(self):
""" simple iterator to go over self.list, returns SourceEntry
types """
for entry in self.list:
yield entry
raise StopIteration
def add(self, type, uri, dist, orig_comps, comment="", pos=-1, file=None):
"""
Add a new source to the sources.list.
The method will search for existing matching repos and will try to
reuse them as far as possible
"""
# create a working copy of the component list so that
# we can modify it later
comps = orig_comps[:]
# check if we have this source already in the sources.list
for source in self.list:
if not source.disabled and not source.invalid and \
source.type == type and uri == source.uri and \
source.dist == dist:
for new_comp in comps:
if new_comp in source.comps:
# we have this component already, delete it
# from the new_comps list
del comps[comps.index(new_comp)]
if len(comps) == 0:
return source
for source in self.list:
# if there is a repo with the same (type, uri, dist) just add the
# components
if not source.disabled and not source.invalid and \
source.type == type and uri == source.uri and \
source.dist == dist:
comps = uniq(source.comps + comps)
source.comps = comps
return source
# if there is a corresponding repo which is disabled, enable it
elif source.disabled and not source.invalid and \
source.type == type and uri == source.uri and \
source.dist == dist and \
len(set(source.comps) & set(comps)) == len(comps):
source.disabled = False
return source
# there isn't any matching source, so create a new line and parse it
line = "%s %s %s" % (type, uri, dist)
for c in comps:
line = line + " " + c
if comment != "":
line = "%s #%s\n" % (line, comment)
line = line + "\n"
new_entry = SourceEntry(line)
if file is not None:
new_entry.file = file
self.matcher.match(new_entry)
self.list.insert(pos, new_entry)
return new_entry
def remove(self, source_entry):
""" remove the specified entry from the sources.list """
self.list.remove(source_entry)
def restore_backup(self, backup_ext):
" restore sources.list files based on the backup extension "
file = apt_pkg.config.find_file("Dir::Etc::sourcelist")
if os.path.exists(file+backup_ext) and \
os.path.exists(file):
shutil.copy(file + backup_ext, file)
# now sources.list.d
partsdir = apt_pkg.config.find_dir("Dir::Etc::sourceparts")
for file in glob.glob("%s/*.list" % partsdir):
if os.path.exists(file + backup_ext):
shutil.copy(file + backup_ext, file)
if apt_pkg._COMPAT_0_7:
restoreBackup = function_deprecated_by(restore_backup)
def backup(self, backup_ext=None):
""" make a backup of the current source files, if no backup extension
is given, the current date/time is used (and returned) """
already_backuped = set()
if backup_ext is None:
backup_ext = time.strftime("%y%m%d.%H%M")
for source in self.list:
if not source.file in already_backuped \
and os.path.exists(source.file):
shutil.copy(source.file, "%s%s" % (source.file, backup_ext))
return backup_ext
def load(self, file):
""" (re)load the current sources """
try:
f = open(file, "r")
lines = f.readlines()
for line in lines:
source = SourceEntry(line, file)
self.list.append(source)
except:
print "could not open file '%s'" % file
else:
f.close()
def save(self):
""" save the current sources """
files = {}
# write an empty default config file if there aren't any sources
if len(self.list) == 0:
path = apt_pkg.config.find_file("Dir::Etc::sourcelist")
header = (
"## See sources.list(5) for more information, especialy\n"
"# Remember that you can only use http, ftp or file URIs\n"
"# CDROMs are managed through the apt-cdrom tool.\n")
open(path, "w").write(header)
return
for source in self.list:
if source.file not in files:
files[source.file] = open(source.file, "w")
files[source.file].write(source.str())
for f in files:
files[f].close()
def check_for_relations(self, sources_list):
"""get all parent and child channels in the sources list"""
parents = []
used_child_templates = {}
for source in sources_list:
# try to avoid checking uninterressting sources
if source.template is None:
continue
# set up a dict with all used child templates and corresponding
# source entries
if source.template.child:
key = source.template
if key not in used_child_templates:
used_child_templates[key] = []
temp = used_child_templates[key]
temp.append(source)
else:
# store each source with children aka. a parent :)
if len(source.template.children) > 0:
parents.append(source)
#print self.used_child_templates
#print self.parents
return (parents, used_child_templates)
class GInstallProgress(gobject.GObject, base.InstallProgress):
"""Installation progress with GObject signals.
Signals:
* status-changed(str: status, int: percent)
* status-started()
* status-finished()
* status-timeout()
* status-error()
* status-conffile()
"""
# Seconds until a maintainer script will be regarded as hanging
INSTALL_TIMEOUT = 5 * 60
__gsignals__ = {
"status-changed": mksig((str, int)),
"status-started": mksig(),
"status-timeout": mksig(),
"status-error": mksig(),
"status-conffile": mksig(),
"status-finished": mksig()
}
def __init__(self, term):
base.InstallProgress.__init__(self)
gobject.GObject.__init__(self)
self.finished = False
self.apt_status = -1
self.time_last_update = time.time()
self.term = term
self.term.connect("child-exited", self.child_exited)
self.env = [
"VTE_PTY_KEEP_FD=%s" % self.writefd, "DEBIAN_FRONTEND=gnome",
"APT_LISTCHANGES_FRONTEND=gtk"
]
self._context = glib.main_context_default()
def child_exited(self, term):
"""Called when a child process exits"""
self.apt_status = term.get_child_exit_status()
self.finished = True
def error(self, pkg, errormsg):
"""Called when an error happens.
Emits: status-error()
"""
self.emit("status-error")
def conffile(self, current, new):
"""Called during conffile.
Emits: status-conffile()
"""
self.emit("status-conffile")
def start_update(self):
"""Called when the update starts.
Emits: status-started()
"""
self.emit("status-started")
def run(self, obj):
"""Run."""
self.finished = False
return base.InstallProgress.run(self, obj)
def finish_update(self):
"""Called when the update finished.
Emits: status-finished()
"""
self.emit("status-finished")
def processing(self, pkg, stage):
"""Called when entering a new stage in dpkg."""
# We have no percentage or alike, send -1 to let the bar pulse.
self.emit("status-changed", ("Installing %s...") % pkg, -1)
def status_change(self, pkg, percent, status):
"""Called when the status changed.
Emits: status-changed(status, percent)
"""
self.time_last_update = time.time()
self.emit("status-changed", status, percent)
def update_interface(self):
"""Called periodically to update the interface.
Emits: status-timeout() [When a timeout happens]
"""
base.InstallProgress.update_interface(self)
while self._context.pending():
self._context.iteration()
if self.time_last_update + self.INSTALL_TIMEOUT < time.time():
self.emit("status-timeout")
def fork(self):
"""Fork the process."""
return self.term.forkpty(envv=self.env)
def wait_child(self):
"""Wait for the child process to exit."""
while not self.finished:
self.update_interface()
time.sleep(0.02)
return self.apt_status
if apt_pkg._COMPAT_0_7:
updateInterface = function_deprecated_by(update_interface)
startUpdate = function_deprecated_by(start_update)
finishUpdate = function_deprecated_by(finish_update)
statusChange = function_deprecated_by(status_change)
waitChild = function_deprecated_by(wait_child)
childExited = function_deprecated_by(child_exited)
class FilteredCache(object):
""" A package cache that is filtered.
Can work on a existing cache or create a new one
"""
def __init__(self, cache=None, progress=None):
if cache is None:
self.cache = Cache(progress)
else:
self.cache = cache
self.cache.connect("cache_post_change", self.filter_cache_post_change)
self.cache.connect("cache_post_open", self.filter_cache_post_change)
self._filtered = {}
self._filters = []
def __len__(self):
return len(self._filtered)
def __getitem__(self, key):
return self.cache[key]
def __iter__(self):
for pkgname in self._filtered:
yield self.cache[pkgname]
def keys(self):
return self._filtered.keys()
def has_key(self, key):
return (key in self._filtered)
def __contains__(self, key):
return (key in self._filtered)
def _reapply_filter(self):
" internal helper to refilter "
self._filtered = {}
for pkg in self.cache:
for f in self._filters:
if f.apply(pkg):
self._filtered[pkg.name] = 1
break
def set_filter(self, filter):
"""Set the current active filter."""
self._filters = []
self._filters.append(filter)
#self._reapplyFilter()
# force a cache-change event that will result in a refiltering
self.cache.cache_post_change()
def filter_cache_post_change(self):
"""Called internally if the cache changes, emit a signal then."""
#print "filterCachePostChange()"
self._reapply_filter()
# def connect(self, name, callback):
# self.cache.connect(name, callback)
def __getattr__(self, key):
"""we try to look exactly like a real cache."""
#print "getattr: %s " % key
return getattr(self.cache, key)
if apt_pkg._COMPAT_0_7:
_reapplyFilter = function_deprecated_by(_reapply_filter)
setFilter = function_deprecated_by(set_filter)
filterCachePostChange = function_deprecated_by(\
filter_cache_post_change)
class Cache(object):
"""Dictionary-like package cache.
The APT cache file contains a hash table mapping names of binary
packages to their metadata. A Cache object is the in-core
representation of the same. It provides access to APTs idea of the
list of available packages.
The cache can be used like a mapping from package names to Package
objects (although only getting items is supported).
Keyword arguments:
progress -- a OpProgress object
rootdir -- a alternative root directory. if that is given
the system sources.list and system lists/ files are
not read, only files relative to the given rootdir
memonly -- build the cache in memory only
"""
def __init__(self, progress=None, rootdir=None, memonly=False):
self._cache = None
self._depcache = None
self._records = None
self._list = None
self._callbacks = {}
self._weakref = weakref.WeakValueDictionary()
self._set = set()
self._fullnameset = set()
self._changes_count = -1
self._sorted_set = None
self.connect("cache_post_open", self._inc_changes_count)
self.connect("cache_post_change", self._inc_changes_count)
if memonly:
# force apt to build its caches in memory
apt_pkg.config.set("Dir::Cache::pkgcache", "")
if rootdir:
if os.path.exists(rootdir + "/etc/apt/apt.conf"):
apt_pkg.read_config_file(apt_pkg.config,
rootdir + "/etc/apt/apt.conf")
if os.path.isdir(rootdir + "/etc/apt/apt.conf.d"):
apt_pkg.read_config_dir(apt_pkg.config,
rootdir + "/etc/apt/apt.conf.d")
apt_pkg.config.set("Dir", rootdir)
apt_pkg.config.set("Dir::State::status",
rootdir + "/var/lib/dpkg/status")
# also set dpkg to the rootdir path so that its called for the
# --print-foreign-architectures call
apt_pkg.config.set("Dir::bin::dpkg",
os.path.join(rootdir, "usr", "bin", "dpkg"))
# create required dirs/files when run with special rootdir
# automatically
self._check_and_create_required_dirs(rootdir)
# Call InitSystem so the change to Dir::State::Status is actually
# recognized (LP: #320665)
apt_pkg.init_system()
self.open(progress)
def _inc_changes_count(self):
"""Increase the number of changes"""
self._changes_count += 1
def _check_and_create_required_dirs(self, rootdir):
"""
check if the required apt directories/files are there and if
not create them
"""
files = [
"/var/lib/dpkg/status",
"/etc/apt/sources.list",
]
dirs = [
"/var/lib/dpkg",
"/etc/apt/",
"/var/cache/apt/archives/partial",
"/var/lib/apt/lists/partial",
]
for d in dirs:
if not os.path.exists(rootdir + d):
#print "creating: ", rootdir + d
os.makedirs(rootdir + d)
for f in files:
if not os.path.exists(rootdir + f):
open(rootdir + f, "w").close()
def _run_callbacks(self, name):
""" internal helper to run a callback """
if name in self._callbacks:
for callback in self._callbacks[name]:
callback()
def open(self, progress=None):
""" Open the package cache, after that it can be used like
a dictionary
"""
if progress is None:
progress = apt.progress.base.OpProgress()
self.op_progress = progress
self._run_callbacks("cache_pre_open")
self._cache = apt_pkg.Cache(progress)
self._depcache = apt_pkg.DepCache(self._cache)
self._records = apt_pkg.PackageRecords(self._cache)
self._list = apt_pkg.SourceList()
self._list.read_main_list()
self._set.clear()
self._fullnameset.clear()
self._sorted_set = None
self._weakref.clear()
self._have_multi_arch = len(apt_pkg.get_architectures()) > 1
progress.op = _("Building data structures")
i = last = 0
size = len(self._cache.packages)
for pkg in self._cache.packages:
if progress is not None and last + 100 < i:
progress.update(i / float(size) * 100)
last = i
# drop stuff with no versions (cruft)
if pkg.has_versions:
self._set.add(pkg.get_fullname(pretty=True))
if self._have_multi_arch:
self._fullnameset.add(pkg.get_fullname(pretty=False))
i += 1
progress.done()
self._run_callbacks("cache_post_open")
def __getitem__(self, key):
""" look like a dictionary (get key) """
try:
return self._weakref[key]
except KeyError:
if key in self._set or key in self._fullnameset:
key = str(key)
pkg = self._weakref[key] = Package(self, self._cache[key])
return pkg
else:
raise KeyError('The cache has no package named %r' % key)
def __iter__(self):
# We iterate sorted over package names here. With this we read the
# package lists linearly if we need to access the package records,
# instead of having to do thousands of random seeks; the latter
# is disastrous if we use compressed package indexes, and slower than
# necessary for uncompressed indexes.
if self._sorted_set is None:
self._sorted_set = sorted(self._set)
for pkgname in self._sorted_set:
yield self[pkgname]
raise StopIteration
def has_key(self, key):
return (key in self._set or key in self._fullnameset)
def __contains__(self, key):
return (key in self._set or key in self._fullnameset)
def __len__(self):
return len(self._set)
def keys(self):
return list(self._set)
def get_changes(self):
""" Get the marked changes """
changes = []
marked_keep = self._depcache.marked_keep
for pkg in self._cache.packages:
if not marked_keep(pkg):
name = pkg.get_fullname(pretty=True)
try:
changes.append(self._weakref[name])
except KeyError:
package = self._weakref[name] = Package(self, pkg)
changes.append(package)
return changes
@deprecated_args
def upgrade(self, dist_upgrade=False):
"""Upgrade all packages.
If the parameter *dist_upgrade* is True, new dependencies will be
installed as well (and conflicting packages may be removed). The
default value is False.
"""
self.cache_pre_change()
self._depcache.upgrade(dist_upgrade)
self.cache_post_change()
@property
def required_download(self):
"""Get the size of the packages that are required to download."""
pm = apt_pkg.PackageManager(self._depcache)
fetcher = apt_pkg.Acquire()
pm.get_archives(fetcher, self._list, self._records)
return fetcher.fetch_needed
@property
def required_space(self):
"""Get the size of the additional required space on the fs."""
return self._depcache.usr_size
@property
def req_reinstall_pkgs(self):
"""Return the packages not downloadable packages in reqreinst state."""
reqreinst = set()
get_candidate_ver = self._depcache.get_candidate_ver
states = frozenset(
(apt_pkg.INSTSTATE_REINSTREQ, apt_pkg.INSTSTATE_HOLD_REINSTREQ))
for pkg in self._cache.packages:
cand = get_candidate_ver(pkg)
if cand and not cand.downloadable and pkg.inst_state in states:
reqreinst.add(pkg.get_fullname(pretty=True))
return reqreinst
def _run_fetcher(self, fetcher):
# do the actual fetching
res = fetcher.run()
# now check the result (this is the code from apt-get.cc)
failed = False
transient = False
err_msg = ""
for item in fetcher.items:
if item.status == item.STAT_DONE:
continue
if item.STAT_IDLE:
transient = True
continue
err_msg += "Failed to fetch %s %s\n" % (item.desc_uri,
item.error_text)
failed = True
# we raise a exception if the download failed or it was cancelt
if res == fetcher.RESULT_CANCELLED:
raise FetchCancelledException(err_msg)
elif failed:
raise FetchFailedException(err_msg)
return res
def _fetch_archives(self, fetcher, pm):
""" fetch the needed archives """
# get lock
lockfile = apt_pkg.config.find_dir("Dir::Cache::Archives") + "lock"
lock = apt_pkg.get_lock(lockfile)
if lock < 0:
raise LockFailedException("Failed to lock %s" % lockfile)
try:
# this may as well throw a SystemError exception
if not pm.get_archives(fetcher, self._list, self._records):
return False
# now run the fetcher, throw exception if something fails to be
# fetched
return self._run_fetcher(fetcher)
finally:
os.close(lock)
def fetch_archives(self, progress=None, fetcher=None):
"""Fetch the archives for all packages marked for install/upgrade.
You can specify either an :class:`apt.progress.base.AcquireProgress()`
object for the parameter *progress*, or specify an already
existing :class:`apt_pkg.Acquire` object for the parameter *fetcher*.
The return value of the function is undefined. If an error occured,
an exception of type :class:`FetchFailedException` or
:class:`FetchCancelledException` is raised.
.. versionadded:: 0.8.0
"""
if progress is not None and fetcher is not None:
raise ValueError("Takes a progress or a an Acquire object")
if progress is None:
progress = apt.progress.text.AcquireProgress()
if fetcher is None:
fetcher = apt_pkg.Acquire(progress)
return self._fetch_archives(fetcher,
apt_pkg.PackageManager(self._depcache))
def is_virtual_package(self, pkgname):
"""Return whether the package is a virtual package."""
try:
pkg = self._cache[pkgname]
except KeyError:
return False
else:
return bool(pkg.has_provides and not pkg.has_versions)
def get_providing_packages(self,
pkgname,
candidate_only=True,
include_nonvirtual=False):
"""Return a list of all packages providing a package.
Return a list of packages which provide the virtual package of the
specified name.
If 'candidate_only' is False, return all packages with at
least one version providing the virtual package. Otherwise,
return only those packages where the candidate version
provides the virtual package.
If 'include_nonvirtual' is True then it will search for all
packages providing pkgname, even if pkgname is not itself
a virtual pkg.
"""
providers = set()
get_candidate_ver = self._depcache.get_candidate_ver
try:
vp = self._cache[pkgname]
if vp.has_versions and not include_nonvirtual:
return list(providers)
except KeyError:
return list(providers)
for provides, providesver, version in vp.provides_list:
pkg = version.parent_pkg
if not candidate_only or (version == get_candidate_ver(pkg)):
name = pkg.get_fullname(pretty=True)
try:
providers.add(self._weakref[name])
except KeyError:
package = self._weakref[name] = Package(self, pkg)
providers.add(package)
return list(providers)
@deprecated_args
def update(self,
fetch_progress=None,
pulse_interval=0,
raise_on_error=True,
sources_list=None):
"""Run the equivalent of apt-get update.
You probably want to call open() afterwards, in order to utilise the
new cache. Otherwise, the old cache will be used which can lead to
strange bugs.
The first parameter *fetch_progress* may be set to an instance of
apt.progress.FetchProgress, the default is apt.progress.FetchProgress()
.
sources_list -- Update a alternative sources.list than the default.
Note that the sources.list.d directory is ignored in this case
"""
lockfile = apt_pkg.config.find_dir("Dir::State::Lists") + "lock"
lock = apt_pkg.get_lock(lockfile)
if lock < 0:
raise LockFailedException("Failed to lock %s" % lockfile)
if sources_list:
old_sources_list = apt_pkg.config.find("Dir::Etc::sourcelist")
old_sources_list_d = apt_pkg.config.find("Dir::Etc::sourceparts")
old_cleanup = apt_pkg.config.find("APT::List-Cleanup")
apt_pkg.config.set("Dir::Etc::sourcelist",
os.path.abspath(sources_list))
apt_pkg.config.set("Dir::Etc::sourceparts", "xxx")
apt_pkg.config.set("APT::List-Cleanup", "0")
slist = apt_pkg.SourceList()
slist.read_main_list()
else:
slist = self._list
try:
if fetch_progress is None:
fetch_progress = apt.progress.base.AcquireProgress()
try:
res = self._cache.update(fetch_progress, slist, pulse_interval)
except SystemError as e:
raise FetchFailedException(e)
if not res and raise_on_error:
raise FetchFailedException()
else:
return res
finally:
os.close(lock)
if sources_list:
apt_pkg.config.set("Dir::Etc::sourcelist", old_sources_list)
apt_pkg.config.set("Dir::Etc::sourceparts", old_sources_list_d)
apt_pkg.config.set("APT::List-Cleanup", old_cleanup)
@deprecated_args
def install_archives(self, pm, install_progress):
"""
The first parameter *pm* refers to an object returned by
apt_pkg.PackageManager().
The second parameter *install_progress* refers to an InstallProgress()
object of the module apt.progress.
"""
# compat with older API
try:
install_progress.startUpdate()
except AttributeError:
install_progress.start_update()
res = install_progress.run(pm)
try:
install_progress.finishUpdate()
except AttributeError:
install_progress.finish_update()
return res
@deprecated_args
def commit(self, fetch_progress=None, install_progress=None):
"""Apply the marked changes to the cache.
The first parameter, *fetch_progress*, refers to a FetchProgress()
object as found in apt.progress, the default being
apt.progress.FetchProgress().
The second parameter, *install_progress*, is a
apt.progress.InstallProgress() object.
"""
# FIXME:
# use the new acquire/pkgmanager interface here,
# raise exceptions when a download or install fails
# and send proper error strings to the application.
# Current a failed download will just display "error"
# which is less than optimal!
if fetch_progress is None:
fetch_progress = apt.progress.base.AcquireProgress()
if install_progress is None:
install_progress = apt.progress.base.InstallProgress()
pm = apt_pkg.PackageManager(self._depcache)
fetcher = apt_pkg.Acquire(fetch_progress)
while True:
# fetch archives first
res = self._fetch_archives(fetcher, pm)
# then install
res = self.install_archives(pm, install_progress)
if res == pm.RESULT_COMPLETED:
break
elif res == pm.RESULT_FAILED:
raise SystemError("installArchives() failed")
elif res == pm.RESULT_INCOMPLETE:
pass
else:
raise SystemError("internal-error: unknown result code "
"from InstallArchives: %s" % res)
# reload the fetcher for media swaping
fetcher.shutdown()
return (res == pm.RESULT_COMPLETED)
def clear(self):
""" Unmark all changes """
self._depcache.init()
# cache changes
def cache_post_change(self):
" called internally if the cache has changed, emit a signal then "
self._run_callbacks("cache_post_change")
def cache_pre_change(self):
""" called internally if the cache is about to change, emit
a signal then """
self._run_callbacks("cache_pre_change")
def connect(self, name, callback):
""" connect to a signal, currently only used for
cache_{post,pre}_{changed,open} """
if not name in self._callbacks:
self._callbacks[name] = []
self._callbacks[name].append(callback)
def actiongroup(self):
"""Return an `ActionGroup` object for the current cache.
Action groups can be used to speedup actions. The action group is
active as soon as it is created, and disabled when the object is
deleted or when release() is called.
You can use the action group as a context manager, this is the
recommended way::
with cache.actiongroup():
for package in my_selected_packages:
package.mark_install()
This way, the action group is automatically released as soon as the
with statement block is left. It also has the benefit of making it
clear which parts of the code run with a action group and which
don't.
"""
return apt_pkg.ActionGroup(self._depcache)
@property
def dpkg_journal_dirty(self):
"""Return True if the dpkg was interrupted
All dpkg operations will fail until this is fixed, the action to
fix the system if dpkg got interrupted is to run
'dpkg --configure -a' as root.
"""
dpkg_status_dir = os.path.dirname(
apt_pkg.config.find_file("Dir::State::status"))
for f in os.listdir(os.path.join(dpkg_status_dir, "updates")):
if fnmatch.fnmatch(f, "[0-9]*"):
return True
return False
@property
def broken_count(self):
"""Return the number of packages with broken dependencies."""
return self._depcache.broken_count
@property
def delete_count(self):
"""Return the number of packages marked for deletion."""
return self._depcache.del_count
@property
def install_count(self):
"""Return the number of packages marked for installation."""
return self._depcache.inst_count
@property
def keep_count(self):
"""Return the number of packages marked as keep."""
return self._depcache.keep_count
if apt_pkg._COMPAT_0_7:
_runCallbacks = function_deprecated_by(_run_callbacks)
getChanges = function_deprecated_by(get_changes)
requiredDownload = AttributeDeprecatedBy('required_download')
additionalRequiredSpace = AttributeDeprecatedBy('required_space')
reqReinstallPkgs = AttributeDeprecatedBy('req_reinstall_pkgs')
_runFetcher = function_deprecated_by(_run_fetcher)
_fetchArchives = function_deprecated_by(_fetch_archives)
isVirtualPackage = function_deprecated_by(is_virtual_package)
getProvidingPackages = function_deprecated_by(get_providing_packages)
installArchives = function_deprecated_by(install_archives)
cachePostChange = function_deprecated_by(cache_post_change)
cachePreChange = function_deprecated_by(cache_pre_change)