def installdeb(self, pkg):
"""
Install the Debian package.
:param pkg: The path to the package to install
:type pkg: str
"""
# Get the DebPackage object and the filename
dpkg = DebPackage(filename=pkg, cache=self.cache)
pkg_name = basename(pkg)
# Look for package conflicts
if not dpkg.check_conflicts():
self.feedback.block(dpkg.conflicts, 'CONFLICT')
self.feedback.error(
'Cannot install package <{0}>, conflicts with:'.format(
pkg_name))
return False
# Get any version in cache
cache_version = dpkg.compare_to_version_in_cache()
action = 'Installed'
# Not installed
if cache_version == dpkg.VERSION_NONE:
self.feedback.info('Package <{0}> not installed'.format(pkg_name))
# Upgrading
if cache_version == dpkg.VERSION_OUTDATED:
return self.feedback.info(
'Package <{0}> has newer version installed'.format(pkg_name))
# Same version
if cache_version == dpkg.VERSION_SAME:
return self.feedback.info(
'Package <{0}> already installed'.format(pkg_name))
# Installed is newer
if cache_version == dpkg.VERSION_NEWER:
self.feedback.info(
'Package <{0}> outdated, upgrading'.format(pkg_name))
action = 'Updated'
# Install the package
dpkg.install()
self.feedback.success('{0}: {1}'.format(action, pkg_name))
def installdeb(self, pkg):
"""
Install the Debian package.
:param pkg: The path to the package to install
:type pkg: str
"""
# Get the DebPackage object and the filename
dpkg = DebPackage(filename=pkg, cache=self.cache)
pkg_name = basename(pkg)
# Look for package conflicts
if not dpkg.check_conflicts():
self.feedback.block(dpkg.conflicts, 'CONFLICT')
self.feedback.error('Cannot install package <{0}>, conflicts with:'.format(pkg_name))
return False
# Get any version in cache
cache_version = dpkg.compare_to_version_in_cache()
action = 'Installed'
# Not installed
if cache_version == dpkg.VERSION_NONE:
self.feedback.info('Package <{0}> not installed'.format(pkg_name))
# Upgrading
if cache_version == dpkg.VERSION_OUTDATED:
self.feedback.info('Package <{0}> outdated, upgrading'.format(pkg_name))
action = 'Updated'
# Same version
if cache_version == dpkg.VERSION_SAME:
return self.feedback.info('Package <{0}> already installed'.format(pkg_name))
# Installed is newer
if cache_version == dpkg.VERSION_NEWER:
return self.feedback.info('Package <{0}> has newer version installed'.format(pkg_name))
# Install the package
dpkg.install()
self.feedback.success('{0}: {1}'.format(action, pkg_name))
class AppDetailsDebFile(AppDetails):
def __init__(self, db, doc=None, application=None):
super(AppDetailsDebFile, self).__init__(db, doc, application)
if doc:
raise ValueError("doc must be None for deb files")
try:
with ExecutionTime("create DebPackage"):
# Cache() used to be faster here than self._cache._cache
# but that is no longer the case with the latest apt
self._deb = DebPackage(self._app.request, self._cache._cache)
except:
self._deb = None
self._pkg = None
if not os.path.exists(self._app.request):
self._error = _("Not found")
self._error_not_found = utf8(_(u"The file \u201c%s\u201d "
"does not exist.")) % utf8(self._app.request)
else:
mimetype = guess_type(self._app.request)
if mimetype[0] != "application/x-debian-package":
self._error = _("Not found")
self._error_not_found = utf8(_(u"The file \u201c%s\u201d "
"is not a software package.")) % utf8(
self._app.request)
else:
# deb files which are corrupt
self._error = _("Internal Error")
self._error_not_found = utf8(_(u"The file \u201c%s\u201d "
"could not be opened.")) % utf8(self._app.request)
return
if self.pkgname and self.pkgname != self._app.pkgname:
# this happens when the deb file has a quirky file name
self._app.pkgname = self.pkgname
# load pkg cache
self._pkg = None
if (self._app.pkgname in self._cache and
self._cache[self._app.pkgname].candidate):
self._pkg = self._cache[self._app.pkgname]
# load xapian document
self._doc = None
try:
self._doc = self._db.get_xapian_document(
self._app.appname, self._app.pkgname)
except:
pass
# check deb and set failure state on error
with ExecutionTime("AppDetailsDebFile._deb.check()"):
if not self._deb.check():
self._error = self._deb._failure_string.strip()
@property
def description(self):
if self._deb:
description = self._deb._sections["Description"]
s = ('\n').join(description.split('\n')[1:]).replace(" .\n", "")
return utf8(s)
return ""
@property
def maintenance_status(self):
pass
@property
def pkgname(self):
if self._deb:
return self._deb._sections["Package"]
@property
def pkg_state(self):
if self._error:
if self._error_not_found:
return PkgStates.NOT_FOUND
else:
return PkgStates.ERROR
if self._deb:
deb_state = self._deb.compare_to_version_in_cache()
if deb_state == DebPackage.VERSION_NONE:
return PkgStates.UNINSTALLED
elif deb_state == DebPackage.VERSION_OUTDATED:
if self._cache[self.pkgname].installed:
return PkgStates.INSTALLED
else:
return PkgStates.UNINSTALLED
elif deb_state == DebPackage.VERSION_SAME:
return PkgStates.REINSTALLABLE
elif deb_state == DebPackage.VERSION_NEWER:
if self._cache[self.pkgname].installed:
return PkgStates.UPGRADABLE
else:
return PkgStates.UNINSTALLED
@property
def summary(self):
if self._deb:
description = self._deb._sections["Description"]
# ensure its utf8(), see #738771
return utf8(description.split('\n')[0])
@property
def display_summary(self):
if self._doc:
name = self._db.get_appname(self._doc)
if name:
return self.summary
else:
# by spec..
return self._db.get_pkgname(self._doc)
return self.summary
@property
def version(self):
if self._deb:
return self._deb._sections["Version"]
@property
def installed_size(self):
installed_size = 0
if self._deb:
try:
installed_size = long(self._deb._sections["Installed-Size"])
except:
pass
return installed_size * 1024
@property
def warning(self):
# FIXME: use more concise warnings
if self._deb:
deb_state = self._deb.compare_to_version_in_cache(
use_installed=False)
if deb_state == DebPackage.VERSION_NONE:
return utf8(
_("Only install this file if you trust the origin."))
elif (not self._cache[self.pkgname].installed and
self._cache[self.pkgname].candidate and
self._cache[self.pkgname].candidate.downloadable):
if deb_state == DebPackage.VERSION_OUTDATED:
return utf8(_("Please install \"%s\" via your normal "
"software channels. Only install this file if you "
"trust the origin.")) % utf8(self.name)
elif deb_state == DebPackage.VERSION_SAME:
return utf8(_("Please install \"%s\" via your normal "
"software channels. Only install this file if you "
"trust the origin.")) % utf8(self.name)
elif deb_state == DebPackage.VERSION_NEWER:
return utf8(_("An older version of \"%s\" is available in "
"your normal software channels. Only install this "
"file if you trust the origin.")) % utf8(self.name)
@property
def website(self):
if self._deb:
website = None
try:
website = self._deb._sections["Homepage"]
except:
pass
if website:
return website
class AppDetailsDebFile(AppDetails):
def __init__(self, db, doc=None, application=None):
super(AppDetailsDebFile, self).__init__(db, doc, application)
if doc:
raise ValueError("doc must be None for deb files")
try:
with ExecutionTime("create DebPackage"):
# Cache() used to be faster here than self._cache._cache
# but that is no longer the case with the latest apt
self._deb = DebPackage(self._app.request, self._cache._cache)
except:
self._deb = None
self._pkg = None
if not os.path.exists(self._app.request):
self._error = _("Not found")
self._error_not_found = utf8(
_(u"The file \u201c%s\u201d "
"does not exist.")) % utf8(self._app.request)
else:
mimetype = guess_type(self._app.request)
if mimetype[0] != "application/x-debian-package":
self._error = _("Not found")
self._error_not_found = utf8(
_(u"The file \u201c%s\u201d "
"is not a software package.")) % utf8(
self._app.request)
else:
# deb files which are corrupt
self._error = _("Internal Error")
self._error_not_found = utf8(
_(u"The file \u201c%s\u201d "
"could not be opened.")) % utf8(self._app.request)
return
if self.pkgname and self.pkgname != self._app.pkgname:
# this happens when the deb file has a quirky file name
self._app.pkgname = self.pkgname
# load pkg cache
self._pkg = None
if (self._app.pkgname in self._cache
and self._cache[self._app.pkgname].candidate):
self._pkg = self._cache[self._app.pkgname]
# load xapian document
self._doc = None
try:
self._doc = self._db.get_xapian_document(
self._app.appname, self._app.pkgname)
except:
pass
# check deb and set failure state on error
with ExecutionTime("AppDetailsDebFile._deb.check()"):
if not self._deb.check():
self._error = self._deb._failure_string.strip()
@property
def description(self):
if self._deb:
description = self._deb._sections["Description"]
s = ('\n').join(description.split('\n')[1:]).replace(" .\n", "")
return utf8(s)
return ""
@property
def maintenance_status(self):
pass
@property
def pkgname(self):
if self._deb:
return self._deb._sections["Package"]
@property
def pkg_state(self):
if self._error:
if self._error_not_found:
return PkgStates.NOT_FOUND
else:
return PkgStates.ERROR
if self._deb:
deb_state = self._deb.compare_to_version_in_cache()
if deb_state == DebPackage.VERSION_NONE:
return PkgStates.UNINSTALLED
elif deb_state == DebPackage.VERSION_OUTDATED:
if self._cache[self.pkgname].installed:
return PkgStates.INSTALLED
else:
return PkgStates.UNINSTALLED
elif deb_state == DebPackage.VERSION_SAME:
return PkgStates.REINSTALLABLE
elif deb_state == DebPackage.VERSION_NEWER:
if self._cache[self.pkgname].installed:
return PkgStates.UPGRADABLE
else:
return PkgStates.UNINSTALLED
@property
def summary(self):
if self._deb:
description = self._deb._sections["Description"]
# ensure its utf8(), see #738771
return utf8(description.split('\n')[0])
@property
def display_summary(self):
if self._doc:
name = self._db.get_appname(self._doc)
if name:
return self.summary
else:
# by spec..
return self._db.get_pkgname(self._doc)
return self.summary
@property
def version(self):
if self._deb:
return self._deb._sections["Version"]
@property
def installed_size(self):
installed_size = 0
if self._deb:
try:
installed_size = long(self._deb._sections["Installed-Size"])
except:
pass
return installed_size * 1024
@property
def warning(self):
# FIXME: use more concise warnings
if self._deb:
deb_state = self._deb.compare_to_version_in_cache(
use_installed=False)
if deb_state == DebPackage.VERSION_NONE:
return utf8(
_("Only install this file if you trust the origin."))
elif (not self._cache[self.pkgname].installed
and self._cache[self.pkgname].candidate
and self._cache[self.pkgname].candidate.downloadable):
if deb_state == DebPackage.VERSION_OUTDATED:
return utf8(
_("Please install \"%s\" via your normal "
"software channels. Only install this file if you "
"trust the origin.")) % utf8(self.name)
elif deb_state == DebPackage.VERSION_SAME:
return utf8(
_("Please install \"%s\" via your normal "
"software channels. Only install this file if you "
"trust the origin.")) % utf8(self.name)
elif deb_state == DebPackage.VERSION_NEWER:
return utf8(
_("An older version of \"%s\" is available in "
"your normal software channels. Only install this "
"file if you trust the origin.")) % utf8(self.name)
@property
def website(self):
if self._deb:
website = None
try:
website = self._deb._sections["Homepage"]
except:
pass
if website:
return website
class DebFile(AbstractPackageFile):
def __init__(self, deb_file):
AbstractPackageFile.__init__(self, deb_file)
self.package = DebPackage(deb_file, CACHE)
self.package.check()
def is_source(self):
try:
self.package['Source']
except KeyError as exception:
if self.arch == 'source':
return True
else:
return False
return True
@property
def requires(self):
return self.package.depends
@property
def arch(self):
return self.package['Architecture']
@property
def name(self):
return self.package.pkgname
@property
def license(self):
try:
return self.package['License']
except KeyError as _:
pass
@property
def conflicts(self):
return self.package.conflicts
@property
def version(self):
return self.package['Version']
@property
def summary(self):
return self.description
@property
def upgradable(self):
return super(DebFile, self).upgradable()
@property
def provides(self):
return self.package.provides
@property
def platform(self):
return None
@property
def description(self):
return self.package['Description']
@property
def installed(self):
return self.package.compare_to_version_in_cache() \
!= DebPackage.VERSION_NONE
@property
def release(self):
try:
return self.package['Distribution']
except KeyError as _:
return 'unstable'
