def resolve(self, filters, package ):
"""
@filters (list) list of filters
@package (list ) list with packages name for resolve
"""
log.info("======== resolve =========")
log.info("filters: %s package:%s " % (filters, package))
cache = Cache()
pkg_dict = cache.resolve( package[0] )
if pkg_dict is None:
self.error(ERROR_INTERNAL_ERROR, "Package Not found on repository")
filter = ConaryFilter(filters)
installed = filter._pkg_is_installed( pkg_dict["name"] )
conary_cli = ConaryPk()
troveTuple = conary_cli.request_query( package[0] )
log.info(">>> %s" % troveTuple)
if installed:
filter.add_installed( troveTuple )
else:
filter.add_available( troveTuple )
package_list = filter.post_process()
log.info("package_list %s" % package_list)
self._show_package_list(package_list)
def get_update_detail(self, package_ids):
'''
Implement the {backend}-get-update_detail functionality
'''
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_INFO)
package_id = package_ids[0]
log.info(package_id)
name, version,arch,summary = pkpackage.get_package_from_id(package_id)
cache = Cache()
pkgDict = cache.resolve(name)
#update = self._get_updated(pkg)
update = ""
obsolete = ""
cve_url = ""
if pkgDict:
if "url" in pkgDict:
vendor_url = pkgDict["url"]
else:
vendor_url = ""
if "longDesc" in pkgDict:
desc = pkgDict["longDesc"]
else:
desc = ""
reboot = self._get_restart(pkgDict.get("name"))
state = self._get_branch( pkgDict.get("label"))
bz_url = self._get_fits(pkgDict.get("label"), pkgDict.get("name"))
#
#def update_detail(self, package_id, updates, obsoletes, vendor_url, bugzilla_url, cve_url, restart, update_text, changelog, state, issued, updated):
self.update_detail(package_id, update, obsolete, vendor_url, bz_url, cve_url,
reboot, desc, changelog="", state= state, issued="", updated = "")
def _do_search(self, filters, searchlist, where = "name"):
"""
searchlist(str)ist as the package for search like
filters(str) as the filter
"""
fltlist = filters
if where != "name" and where != "details" and where != "group" and where!= "all":
log.info("where %s" % where)
self.error(ERROR_UNKNOWN, "DORK---- search where not found")
cache = Cache()
log.debug((where,type(where)))
pkgList = cache.search(searchlist, where )
if len(pkgList) > 0 :
#for i in troveTupleList:
# log.info("FOUND!!!!!! %s " % i["name"] )
log.info("FOUND (%s) elements " % len(pkgList) )
for pkgDict in pkgList:
self._add_package( ( pkgDict["name"], None, None), pkgDict )
self._resolve_list( fltlist )
else:
log.info("NOT FOUND %s " % searchlist )
self.message(MESSAGE_COULD_NOT_FIND_PACKAGE,"search not found")
def resolve(self, filters, package ):
"""
@filters (list) list of filters
@package (list ) list with packages name for resolve
"""
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_INFO)
log.info("filters: %s package:%s " % (filters, package))
cache = Cache()
pkg_dict = cache.resolve( package[0] )
log.info(pkg_dict)
if pkg_dict is None:
return None
log.info("doing a resolve")
filter = ConaryFilter(filters)
trove = None
trove_installed = self.conary.query( pkg_dict.get("name") )
if trove_installed:
pkg = self._convert_package( trove_installed[0], pkg_dict )
log.info( pkg)
filter.add_installed( [ pkg ] )
trove_available = self.conary.request_query( pkg_dict.get("name") )
if trove_available:
pkg = self._convert_package( trove_available[0], pkg_dict )
filter.add_available( [ pkg ] )
package_list = filter.post_process()
log.info("package_list %s" % package_list)
self._show_package_list(package_list)
def __init__(self, args):
PackageKitBaseBackend.__init__(self, args)
# conary configurations
conary = conarypk.ConaryPk()
self.cfg = conary.cfg
self.client = conary.cli
self.conary = conary
self.xmlcache = XMLCache(self.conary.get_labels())
def __init__(self, args):
PackageKitBaseBackend.__init__(self, args)
# conary configurations
conary = ConaryPk()
self.cfg = conary.cfg
self.client = conary.cli
self.conary = conary
self.callback = UpdateCallback(self, self.cfg)
self.client.setUpdateCallback(self.callback)
self.xmlcache = XMLCache()
def get_package_id(self, name, versionObj, flavor):
version = versionObj.trailingRevision()
cache = Cache()
pkg = cache.resolve(name)
#pkg["shortDesc"] = "."
arch = self._get_arch(flavor)
#data = versionObj.asString() + "#"
data = ""
if pkg:
data = self._format_metadata(pkg)
return pkpackage.get_package_id(name, version, arch, data)
def get_package_id(self, name, versionObj, flavor):
version = versionObj.trailingRevision()
arch = self._get_arch(flavor)
cache = Cache()
pkg = cache.resolve(name)
data = versionObj.asString() + "#"
if pkg:
try:
data +=str(pkg)
except:
pass
return pkpackage.get_package_id(name, version, arch, data)
def __init__(self, args):
PackageKitBaseBackend.__init__(self, args)
# conary configurations
conary = conarypk.ConaryPk()
self.cfg = conary.cfg
self.client = conary.cli
self.conary = conary
self.xmlcache = XMLCache(self.conary.get_labels())
def get_details(self, package_ids):
'''
Print a detailed description for a given package
'''
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_INFO)
log.info("========== get_details =============")
log.info(package_ids[0])
package_id = package_ids[0]
#name, version, flavor, installed = self._findPackage(package_id)
name,version,arch,data = pkpackage.get_package_from_id(package_id)
cache = Cache()
pkgDict = cache.resolve(name)
if name and pkgDict:
shortDesc = ""
longDesc = ""
url = ""
categories = None
license = ""
if "shortDesc" in pkgDict:
shortDesc = pkgDict["shortDesc"]
if "longDesc" in pkgDict:
longDesc = pkgDict["longDesc"]
if "url" in pkgDict:
url = pkgDict["url"] #+ ";%s" % pkgDict["url"].replace("http://","")
if "category" in pkgDict:
categories = Cache().getGroup( pkgDict['category'])
if "licenses" in pkgDict:
license = self._get_license(pkgDict["licenses"])
log.info(license)
# Package size goes here, but I don't know how to find that for conary packages.
#
#LICENSE_UNKNOWN = "unknown"
pkg_id = package_id.split(";")
pkg_id[3] = pkgDict["label"]
package_id = ";".join(pkg_id)
log.info(package_id)
self.details(package_id, license, categories, longDesc, url, 0)
def __init__(self, args):
PackageKitBaseBackend.__init__(self, args)
# conary configurations
conary = ConaryPk()
self.cfg = conary.cfg
self.client = conary.cli
self.conary = conary
self.callback = UpdateCallback(self, self.cfg)
self.client.setUpdateCallback(self.callback)
self.xmlcache = XMLCache()
def _do_search(self, filters, searchlist, where = "name"):
"""
searchlist(str)ist as the package for search like
filters(str) as the filter
"""
fltlist = filters.split(';')
if where != "name" and where != "details" and where != "group":
log.info("where %s" % where)
self.error(ERROR_UNKNOWN, "DORK---- search where not found")
cache = Cache()
log.debug((searchlist, fltlist))
troveTupleList = cache.search(searchlist, where )
if len(troveTupleList) > 0 :
for i in troveTupleList:
log.info("FOUND!!!!!! %s " % i["name"] )
log.info("FOUND (%s) elements " % len(troveTupleList) )
else:
log.info("NOT FOUND %s " % searchlist )
self.error(ERROR_PACKAGE_NOT_FOUND, "Not Found %s " % searchlist )
self._resolve_list( fltlist, troveTupleList )
class PackageKitConaryBackend(PackageKitBaseBackend):
# Packages there require a reboot
rebootpkgs = ("kernel", "glibc", "hal", "dbus")
restartpkgs = ("PackageKit", "gnome-packagekit")
packages = []
#{{{ Packages structure
"""
packages = {
pkg_name: {
'trove': ( name,version,flavor)
'metadata': pkgDict,
}
}
"""
#}}}
#{{{ Init
def __init__(self, args):
PackageKitBaseBackend.__init__(self, args)
# conary configurations
conary = ConaryPk()
self.cfg = conary.cfg
self.client = conary.cli
self.conary = conary
self.callback = UpdateCallback(self, self.cfg)
self.client.setUpdateCallback(self.callback)
self.xmlcache = XMLCache()
def _freezeData(self, version, flavor):
frzVersion = version.freeze()
frzFlavor = flavor.freeze()
return ','.join([frzVersion, frzFlavor])
def _thawData(self, frzVersion, frzFlavor):
version = versions.ThawVersion(frzVersion)
flavor = deps.ThawFlavor(frzFlavor)
return version, flavor
#}}}
def _get_arch(self, flavor):
return _get_arch(flavor)
@ExceptionHandler
def check_installed(self, troveTuple):
log.info("============check installed =========")
result = self.conary.query(troveTuple[0])
if result:
installed = INFO_INSTALLED
else:
installed = INFO_AVAILABLE
return installed
def get_package_id_new(self, pkg):
name, version, flavor = pkg.get("trove")
metadata = pkg.get("metadata")
data = ""
if metadata:
if "shortDesc" in metadata:
data = metadata['shortDesc'].decode("UTF")
if data == "." or data == "":
data = name.replace("-", ' ').capitalize()
return pkpackage.get_package_id(name, version.trailingRevision(),
self._get_arch(flavor), data)
@ExceptionHandler
def get_package_id(self, name, versionObj, flavor):
version = versionObj.trailingRevision()
pkg = self.xmlcache.resolve(name)
#pkg["shortDesc"] = "."
arch = self._get_arch(flavor)
#data = versionObj.asString() + "#"
data = ""
if pkg:
if "shortDesc" in pkg:
data = pkg['shortDesc'].decode("UTF")
if data == "." or data == "":
data = name.replace("-", ' ').capitalize()
return pkpackage.get_package_id(name, version, arch, data)
@ExceptionHandler
def get_package_from_id(self, package_id):
""" package_id(string) =
"dpaster;0.1-3-1;x86;Summary"
"""
log.info(
"=========== get package from package_id ======================")
name, verString, archString, data = pkpackage.get_package_from_id(
package_id)
trove = self.conary.request_query(name)
if trove:
return trove
else:
return cli.query(name)
def _search_package(self, name):
for i, pkg in enumerate(self.packages):
if pkg["trove"][0] == name:
return i, pkg
return None, None
def _edit_package(self, trove, pkgDict, status):
for i, pkg in enumerate(self.packages):
if pkg["trove"] == trove:
name, version, flavor = pkg.get("trove")
self.packages[i] = dict(trove=(name, version, flavor),
pkgDict=pkgDict)
return i, self.packages[i]
def _convert_package(self, trove, pkgDict):
return dict(trove=trove, metadata=pkgDict)
def _add_package(self, trove, pkgDict):
self.packages.append(self._convert_package(trove, pkgDict))
def _do_search(self, filters, searchlist, where="name"):
"""
searchlist(str)ist as the package for search like
filters(str) as the filter
"""
fltlist = filters
if where != "name" and where != "details" and where != "group" and where != "all":
log.info("where %s" % where)
self.error(ERROR_UNKNOWN, "DORK---- search where not found")
log.debug((searchlist, where))
log.info("||||||||||||||||||||||||||||searching on cache... ")
pkgList = self.xmlcache.search(searchlist, where)
log.info("|||||||||||||||||||||||||||||1end searching on cache... ")
if len(pkgList) > 0:
#for i in troveTupleList:
# log.info("FOUND!!!!!! %s " % i["name"] )
log.info("FOUND (%s) elements " % len(pkgList))
for pkgDict in pkgList:
self._add_package((pkgDict["name"], None, None), pkgDict)
self._resolve_list(fltlist)
else:
log.info("NOT FOUND %s " % searchlist)
self.message(MESSAGE_COULD_NOT_FIND_PACKAGE, "search not found")
#self.error(ERROR_INTERNAL_ERROR, "packagenotfound")
def _get_update(self, applyList, cache=True):
from conary.conaryclient.update import NoNewTrovesError, DepResolutionFailure
self.allow_cancel(False)
updJob = self.client.newUpdateJob()
jobPath = self.xmlcache.checkCachedUpdateJob(applyList)
if cache and jobPath:
try:
log.info("Using previously cached update job at %s" %
(jobPath, ))
updJob.thaw(jobPath)
except IOError, err:
log.error("Failed to read update job at %s (error=%s)" %
(jobPath, str(err)))
updJob = None
else:
class PackageKitConaryBackend(PackageKitBaseBackend):
# Packages there require a reboot
rebootpkgs = ("kernel", "glibc", "hal", "dbus")
restartpkgs = ("PackageKit","gnome-packagekit")
packages = []
#{{{ Packages structure
"""
packages = {
pkg_name: {
'trove': ( name,version,flavor)
'metadata': pkgDict,
}
}
"""
#}}}
#{{{ Init
def __init__(self, args):
PackageKitBaseBackend.__init__(self, args)
# conary configurations
conary = ConaryPk()
self.cfg = conary.cfg
self.client = conary.cli
self.conary = conary
self.callback = UpdateCallback(self, self.cfg)
self.client.setUpdateCallback(self.callback)
self.xmlcache = XMLCache()
def _freezeData(self, version, flavor):
frzVersion = version.freeze()
frzFlavor = flavor.freeze()
return ','.join([frzVersion, frzFlavor])
def _thawData(self, frzVersion, frzFlavor ):
version = versions.ThawVersion(frzVersion)
flavor = deps.ThawFlavor(frzFlavor)
return version, flavor
#}}}
def _get_arch(self, flavor):
return _get_arch(flavor)
@ExceptionHandler
def check_installed(self, troveTuple):
log.info("============check installed =========")
result = self.conary.query(troveTuple[0])
if result:
installed = INFO_INSTALLED
else:
installed = INFO_AVAILABLE
return installed
def get_package_id_new(self,pkg):
name,version,flavor = pkg.get("trove")
metadata = pkg.get("metadata")
data = ""
if metadata:
if "shortDesc" in metadata:
data = metadata['shortDesc'].decode("UTF")
if data == "." or data == "":
data = name.replace("-",' ').capitalize()
return pkpackage.get_package_id(name, version.trailingRevision(), self._get_arch(flavor), data)
@ExceptionHandler
def get_package_id(self, name, versionObj, flavor):
version = versionObj.trailingRevision()
pkg = self.xmlcache.resolve(name)
#pkg["shortDesc"] = "."
arch = self._get_arch(flavor)
#data = versionObj.asString() + "#"
data = ""
if pkg:
if "shortDesc" in pkg:
data = pkg['shortDesc'].decode("UTF")
if data == "." or data == "":
data = name.replace("-",' ').capitalize()
return pkpackage.get_package_id(name, version, arch, data)
@ExceptionHandler
def get_package_from_id(self, package_id):
""" package_id(string) =
"dpaster;0.1-3-1;x86;Summary"
"""
log.info("=========== get package from package_id ======================")
name, verString, archString, data = pkpackage.get_package_from_id(package_id)
trove = self.conary.request_query(name)
if trove:
return trove
else:
return cli.query(name)
def _search_package( self, name ):
for i,pkg in enumerate(self.packages):
if pkg["trove"][0] == name:
return i,pkg
return None,None
def _edit_package(self, trove, pkgDict, status):
for i,pkg in enumerate(self.packages):
if pkg["trove"] == trove:
name,version, flavor = pkg.get("trove")
self.packages[i] = dict(
trove = (name,version, flavor ),
pkgDict = pkgDict
)
return i, self.packages[i]
def _convert_package( self, trove , pkgDict ):
return dict(
trove = trove ,
metadata = pkgDict
)
def _add_package(self, trove, pkgDict):
self.packages.append( self._convert_package(trove, pkgDict) )
def _do_search(self, filters, searchlist, where = "name"):
"""
searchlist(str)ist as the package for search like
filters(str) as the filter
"""
fltlist = filters
if where != "name" and where != "details" and where != "group" and where!= "all":
log.info("where %s" % where)
self.error(ERROR_UNKNOWN, "DORK---- search where not found")
log.debug((searchlist, where))
log.info("||||||||||||||||||||||||||||searching on cache... ")
pkgList = self.xmlcache.search(searchlist, where )
log.info("|||||||||||||||||||||||||||||1end searching on cache... ")
if len(pkgList) > 0 :
#for i in troveTupleList:
# log.info("FOUND!!!!!! %s " % i["name"] )
log.info("FOUND (%s) elements " % len(pkgList) )
for pkgDict in pkgList:
self._add_package( ( pkgDict["name"], None, None), pkgDict )
self._resolve_list( fltlist )
else:
log.info("NOT FOUND %s " % searchlist )
self.message(MESSAGE_COULD_NOT_FIND_PACKAGE,"search not found")
#self.error(ERROR_INTERNAL_ERROR, "packagenotfound")
def _get_update(self, applyList, cache=True):
from conary.conaryclient.update import NoNewTrovesError,DepResolutionFailure
self.allow_cancel(False)
updJob = self.client.newUpdateJob()
jobPath = self.xmlcache.checkCachedUpdateJob(applyList)
if cache and jobPath:
try:
log.info("Using previously cached update job at %s" % (jobPath,))
updJob.thaw(jobPath)
except IOError, err:
log.error("Failed to read update job at %s (error=%s)" % (jobPath, str(err)))
updJob = None
else:
class PackageKitConaryBackend(PackageKitBaseBackend):
# Packages that require a reboot
rebootpkgs = ("kernel", "glibc", "hal", "dbus")
restartpkgs = ("PackageKit","gnome-packagekit")
def __init__(self, args):
PackageKitBaseBackend.__init__(self, args)
# conary configurations
conary = conarypk.ConaryPk()
self.cfg = conary.cfg
self.client = conary.cli
self.conary = conary
self.xmlcache = XMLCache(self.conary.get_labels())
def _get_package_name_from_ids(self, package_ids):
return [split_package_id(x)[0] for x in package_ids]
def _format_package_summary(self, name, short_desc):
data = short_desc
if data == "." or data == "":
data = name.replace("-",' ').capitalize()
return data
def _search_package(self, pkg_list, name):
for pkg in pkg_list:
if pkg["name"] == name:
return pkg
return None
def _convert_package(self, trovetuple, metadata):
return dict(
trove = trovetuple,
metadata = metadata
)
def _do_search(self, filters, searchlist, where = "name"):
"""
searchlist(str)ist as the package for search like
filters(str) as the filter
"""
if where not in ("name", "details", "group", "all"):
self.error(ERROR_UNKNOWN, "DORK---- search where not found")
pkgList = self.xmlcache.search(searchlist, where )
if len(pkgList) > 0 :
pkgs = self._resolve_list(pkgList, filters)
self._show_package_list(pkgs)
else:
self.message(MESSAGE_COULD_NOT_FIND_PACKAGE,"search not found")
def _resolve_list(self, pkg_list, filters):
pkgFilter = ConaryFilter()
installed = []
if FILTER_NOT_INSTALLED not in filters:
installed = self._resolve_local(pkgFilter, pkg_list)
if FILTER_INSTALLED not in filters:
pkg_list = [x for x in pkg_list if x not in installed]
self._resolve_repo(pkgFilter, pkg_list)
package_list = pkgFilter.post_process()
return package_list
def _resolve_local(self, pkgFilter, pkg_list):
'''Find out installed packages from pkg_list
If a package from pkg_list can be found locally, add it (after some
convertion) to pkgFilter.
Returns the list of installed packages.
'''
ret = []
troves_all = [(p["name"], None, None) for p in pkg_list]
troves_local = self.client.db.findTroves(None, troves_all,
allowMissing=True)
for trv in troves_local:
pkg = self._search_package(pkg_list, trv[0])
ret.append(pkg)
# A package may have different versions/flavors installed.
for t in troves_local[trv]:
pkgFilter.add_installed([self._convert_package(t, pkg)])
return ret
def _resolve_repo(self, pkgFilter, pkg_list):
'''Find out packages from pkg_list that are available in the repository
If a package from pkg_list can be found in the repo, add it (after some
convertion) to pkgFilter.
No return value.
'''
troves_all = [(pkg["name"], None, self.conary.flavor) for pkg in
pkg_list]
troves_repo = self.client.repos.findTroves(self.conary.default_label,
troves_all, allowMissing=True)
for trv in troves_repo:
# only use the first trove in the list
t = troves_repo[trv][0]
pkg = self._search_package(pkg_list, t[0])
pkgFilter.add_available([self._convert_package(t, pkg)])
def resolve(self, filters, package ):
"""
@filters (list) list of filters
@package (list ) list with packages name for resolve
"""
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_INFO)
pkg_dict = self.xmlcache.resolve( package[0] )
if pkg_dict is None:
return None
pkgs = self._resolve_list([pkg_dict], filters)
self._show_package_list(pkgs)
def _show_package_list(self, lst):
'''Emit Package signals for a list of packages
pkgs should be a list of (trove, status) tuples.
Trove is a dict of {(name, version, flavor), metadata}, as constructed
by _convert_package.
'''
def is_redirected_package(version):
# The format of a revision string is
# "<upstream version>-<source count>-<build count>".
# If upstream version is 0, the package has become nil.
return version.split("-")[0] == "0"
for pkg, status in lst:
name, v, f = pkg["trove"]
version = str(v.trailingRevision())
if is_redirected_package(version):
continue
label = str(v.trailingLabel())
arch = conarypk.get_arch(f)
pkg_id = get_package_id(name, version, arch, label)
summary = self._format_package_summary(name,
pkg["metadata"].get("shortDesc", "").decode("UTF"))
self.package(pkg_id, status, summary)
def search_group(self, options, searchlist):
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_QUERY)
self._do_search(options, searchlist, 'group')
def search_file(self, filters, search ):
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_QUERY)
name = self.conary.search_path( search )
if name:
if ":" in name:
name = name.split(":")[0]
self.resolve( filters, [name])
def search_name(self, options, searchlist):
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_QUERY)
self._do_search(options, searchlist, 'name')
def search_details(self, options, search):
self.allow_cancel(True)
#self.percentage(None)
self.status(STATUS_QUERY)
self._do_search(options, search, 'details' )
def get_packages(self, filters):
self.allow_cancel(False)
self.status(STATUS_QUERY)
self._do_search(filters, "", 'all' )
def get_files(self, package_ids):
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_INFO)
for package_id in package_ids:
name, version, arch, data = split_package_id(package_id)
files = self.conary.list_files('%s=%s[is: %s]' %
(name, version, arch))
self.files(package_id, ';'.join(files))
@ConaryExceptionHandler
def update_system(self, only_trusted):
# FIXME: use only_trusted
self.allow_cancel(False)
self.status(STATUS_UPDATE)
cb = UpdateSystemCallback(self, self.cfg)
self.conary.updateall(cb, dry_run=False)
def refresh_cache(self, force):
# TODO: use force ?
self.percentage(None)
self.status(STATUS_REFRESH_CACHE)
self.percentage(None)
self.xmlcache.refresh()
def _display_update_jobs(self, install_jobs, erase_jobs, update_jobs):
'''Emit package status for a list of installing/erasing/updating jobs
'''
ret = []
for (name, (oldVer, oldFla), (newVer, newFla)) in install_jobs:
ret.append((name, newVer, newFla, INFO_INSTALLING))
for (name, (oldVer, oldFla), (newVer, newFla)) in erase_jobs:
ret.append((name, oldVer, oldFla, INFO_REMOVING))
for (name, (oldVer, oldFla), (newVer, newFla)) in update_jobs:
ret.append((name, oldVer, oldFla, INFO_UPDATING))
pkgs = [(self._convert_package((n, v, f), {}), info)
for (n, v, f, info) in ret]
self._show_package_list(pkgs)
def install_packages(self, only_trusted, package_ids):
self._install_packages(only_trusted, package_ids)
def simulate_install_packages(self, package_ids):
return self._install_packages(False, package_ids, simulate=True)
@ConaryExceptionHandler
def _install_packages(self, only_trusted, package_ids, simulate=False):
self.allow_cancel(False)
self.percentage(0)
self.status(STATUS_RUNNING)
pkglist = _get_trovespec_from_ids(package_ids)
cb = UpdateCallback(self, self.cfg)
updJob, suggMap = self.conary.install(pkglist, cb, simulate)
if simulate:
pkgs = self._get_package_name_from_ids(package_ids)
installs, erases, updates = conarypk.parse_jobs(updJob,
excludes=pkgs, show_components=False)
self._display_update_jobs(installs, erases, updates)
def remove_packages(self, allowDeps, autoremove, package_ids):
self. _remove_packages(allowDeps, autoremove, package_ids)
def simulate_remove_packages(self, package_ids):
return self._remove_packages(False, False, package_ids, simulate=True)
@ConaryExceptionHandler
def _remove_packages(self, allowDeps, autoremove, package_ids, simulate=False):
# TODO: use autoremove
self.allow_cancel(False)
self.percentage(0)
self.status(STATUS_RUNNING)
pkglist = _get_trovespec_from_ids(package_ids)
cb = RemoveCallback(self, self.cfg)
updJob, suggMap = self.conary.erase(pkglist, cb, simulate)
if simulate:
pkgs = self._get_package_name_from_ids(package_ids)
installs, erases, updates = conarypk.parse_jobs(updJob,
excludes=pkgs, show_components=False)
self._display_update_jobs(installs, erases, updates)
def _check_for_reboot(self, name):
if name in self.rebootpkgs:
self.require_restart(RESTART_SYSTEM, "")
def get_update_detail(self, package_ids):
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_INFO)
for package_id in package_ids:
name, version, arch, label = split_package_id(package_id)
pkgDict = self.xmlcache.resolve(name)
update = ""
obsolete = ""
cve_url = ""
if pkgDict:
vendor_url = pkgDict.get("url","")
desc = pkgDict.get("longDesc","")
reboot = self._get_restart(name)
state = _get_branch(label)
bz_url = _get_fits(label)
self.update_detail(package_id, update, obsolete, vendor_url, bz_url, cve_url,
reboot, desc, changelog="", state= state, issued="", updated = "")
def get_details(self, package_ids):
'''
Print a detailed description for a given package
'''
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_INFO)
for package_id in package_ids:
name, version, arch, data = split_package_id(package_id)
pkgDict = self.xmlcache.resolve(name)
if name and pkgDict:
longDesc = ""
url = ""
categories = None
licenses = ""
longDesc = pkgDict.get("longDesc", "")
url = pkgDict.get("url", "")
categories = self.xmlcache.getGroup(pkgDict.get("category",""))
licenses = _get_license(pkgDict.get("licenses",""))
size = pkgDict.get("size", 0)
self.details(package_id, licenses, categories, longDesc, url, size)
def _get_restart(self, name):
if name in self.rebootpkgs:
return RESTART_SYSTEM
elif name in self.restartpkgs:
return RESTART_APPLICATION
else:
return RESTART_NONE
def _get_update_priority(self, name):
if name in self.rebootpkgs:
return INFO_SECURITY
elif name in self.restartpkgs:
return INFO_SECURITY
else:
return INFO_NORMAL
def _display_updates(self, jobs):
'''Emit Package signals for a list of update jobs
jobs should only contain installs and updates. Shouldn't get any erase
jobs.
'''
ret = []
for (name, (oldVer, oldFla), (newVer, newFla)) in jobs:
info = self._get_update_priority(name)
ret.append((name, newVer, newFla, info))
pkgs = [(self._convert_package((n, v, f), {}), info)
for (n, v, f, info) in ret]
self._show_package_list(pkgs)
@ConaryExceptionHandler
def get_updates(self, filters):
self.allow_cancel(True)
self.percentage(0)
self.status(STATUS_INFO)
cb = GetUpdateCallback(self, self.cfg)
updJob, suggMap = self.conary.updateall(cb, dry_run=True)
installs, erases, updates = conarypk.parse_jobs(updJob,
show_components=False)
self._display_updates(installs + updates)
def get_repo_list(self, filters):
labels = self.conary.get_labels()
self.status(STATUS_QUERY)
for repo in labels:
self.repo_detail(repo, repo, True)
class PackageKitConaryBackend(PackageKitBaseBackend):
# Packages that require a reboot
rebootpkgs = ("kernel", "glibc", "hal", "dbus")
restartpkgs = ("PackageKit", "gnome-packagekit")
def __init__(self, args):
PackageKitBaseBackend.__init__(self, args)
# conary configurations
conary = conarypk.ConaryPk()
self.cfg = conary.cfg
self.client = conary.cli
self.conary = conary
self.xmlcache = XMLCache(self.conary.get_labels())
def _get_package_name_from_ids(self, package_ids):
return [split_package_id(x)[0] for x in package_ids]
def _format_package_summary(self, name, short_desc):
data = short_desc
if data == "." or data == "":
data = name.replace("-", ' ').capitalize()
return data
def _search_package(self, pkg_list, name):
for pkg in pkg_list:
if pkg["name"] == name:
return pkg
return None
def _convert_package(self, trovetuple, metadata):
return dict(trove=trovetuple, metadata=metadata)
def _do_search(self, filters, searchlist, where="name"):
"""
searchlist(str)ist as the package for search like
filters(str) as the filter
"""
if where not in ("name", "details", "group", "all"):
self.error(ERROR_UNKNOWN, "DORK---- search where not found")
pkgList = self.xmlcache.search(searchlist, where)
if len(pkgList) > 0:
pkgs = self._resolve_list(pkgList, filters)
self._show_package_list(pkgs)
else:
self.message(MESSAGE_COULD_NOT_FIND_PACKAGE, "search not found")
def _resolve_list(self, pkg_list, filters):
pkgFilter = ConaryFilter()
installed = []
if FILTER_NOT_INSTALLED not in filters:
installed = self._resolve_local(pkgFilter, pkg_list)
if FILTER_INSTALLED not in filters:
pkg_list = [x for x in pkg_list if x not in installed]
self._resolve_repo(pkgFilter, pkg_list)
package_list = pkgFilter.post_process()
return package_list
def _resolve_local(self, pkgFilter, pkg_list):
'''Find out installed packages from pkg_list
If a package from pkg_list can be found locally, add it (after some
convertion) to pkgFilter.
Returns the list of installed packages.
'''
ret = []
troves_all = [(p["name"], None, None) for p in pkg_list]
troves_local = self.client.db.findTroves(None,
troves_all,
allowMissing=True)
for trv in troves_local:
pkg = self._search_package(pkg_list, trv[0])
ret.append(pkg)
# A package may have different versions/flavors installed.
for t in troves_local[trv]:
pkgFilter.add_installed([self._convert_package(t, pkg)])
return ret
def _resolve_repo(self, pkgFilter, pkg_list):
'''Find out packages from pkg_list that are available in the repository
If a package from pkg_list can be found in the repo, add it (after some
convertion) to pkgFilter.
No return value.
'''
troves_all = [(pkg["name"], None, self.conary.flavor)
for pkg in pkg_list]
troves_repo = self.client.repos.findTroves(self.conary.default_label,
troves_all,
allowMissing=True)
for trv in troves_repo:
# only use the first trove in the list
t = troves_repo[trv][0]
pkg = self._search_package(pkg_list, t[0])
pkgFilter.add_available([self._convert_package(t, pkg)])
def resolve(self, filters, package):
"""
@filters (list) list of filters
@package (list ) list with packages name for resolve
"""
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_INFO)
pkg_dict = self.xmlcache.resolve(package[0])
if pkg_dict is None:
return None
pkgs = self._resolve_list([pkg_dict], filters)
self._show_package_list(pkgs)
def _show_package_list(self, lst):
'''Emit Package signals for a list of packages
pkgs should be a list of (trove, status) tuples.
Trove is a dict of {(name, version, flavor), metadata}, as constructed
by _convert_package.
'''
def is_redirected_package(version):
# The format of a revision string is
# "<upstream version>-<source count>-<build count>".
# If upstream version is 0, the package has become nil.
return version.split("-")[0] == "0"
for pkg, status in lst:
name, v, f = pkg["trove"]
version = str(v.trailingRevision())
if is_redirected_package(version):
continue
label = str(v.trailingLabel())
arch = conarypk.get_arch(f)
pkg_id = get_package_id(name, version, arch, label)
summary = self._format_package_summary(
name, pkg["metadata"].get("shortDesc", "").decode("UTF"))
self.package(pkg_id, status, summary)
def search_group(self, options, searchlist):
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_QUERY)
self._do_search(options, searchlist, 'group')
def search_file(self, filters, search):
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_QUERY)
name = self.conary.search_path(search)
if name:
if ":" in name:
name = name.split(":")[0]
self.resolve(filters, [name])
def search_name(self, options, searchlist):
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_QUERY)
self._do_search(options, searchlist, 'name')
def search_details(self, options, search):
self.allow_cancel(True)
#self.percentage(None)
self.status(STATUS_QUERY)
self._do_search(options, search, 'details')
def get_packages(self, filters):
self.allow_cancel(False)
self.status(STATUS_QUERY)
self._do_search(filters, "", 'all')
def get_files(self, package_ids):
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_INFO)
for package_id in package_ids:
name, version, arch, data = split_package_id(package_id)
files = self.conary.list_files('%s=%s[is: %s]' %
(name, version, arch))
self.files(package_id, ';'.join(files))
@ConaryExceptionHandler
def update_system(self, only_trusted):
# FIXME: use only_trusted
self.allow_cancel(False)
self.status(STATUS_UPDATE)
cb = UpdateSystemCallback(self, self.cfg)
self.conary.updateall(cb, dry_run=False)
def refresh_cache(self, force):
# TODO: use force ?
self.percentage(None)
self.status(STATUS_REFRESH_CACHE)
self.percentage(None)
self.xmlcache.refresh()
def _display_update_jobs(self, install_jobs, erase_jobs, update_jobs):
'''Emit package status for a list of installing/erasing/updating jobs
'''
ret = []
for (name, (oldVer, oldFla), (newVer, newFla)) in install_jobs:
ret.append((name, newVer, newFla, INFO_INSTALLING))
for (name, (oldVer, oldFla), (newVer, newFla)) in erase_jobs:
ret.append((name, oldVer, oldFla, INFO_REMOVING))
for (name, (oldVer, oldFla), (newVer, newFla)) in update_jobs:
ret.append((name, oldVer, oldFla, INFO_UPDATING))
pkgs = [(self._convert_package((n, v, f), {}), info)
for (n, v, f, info) in ret]
self._show_package_list(pkgs)
def install_packages(self, only_trusted, package_ids):
self._install_packages(only_trusted, package_ids)
def simulate_install_packages(self, package_ids):
return self._install_packages(False, package_ids, simulate=True)
@ConaryExceptionHandler
def _install_packages(self, only_trusted, package_ids, simulate=False):
self.allow_cancel(False)
self.percentage(0)
self.status(STATUS_RUNNING)
pkglist = _get_trovespec_from_ids(package_ids)
cb = UpdateCallback(self, self.cfg)
updJob, suggMap = self.conary.install(pkglist, cb, simulate)
if simulate:
pkgs = self._get_package_name_from_ids(package_ids)
installs, erases, updates = conarypk.parse_jobs(
updJob, excludes=pkgs, show_components=False)
self._display_update_jobs(installs, erases, updates)
def remove_packages(self, allowDeps, autoremove, package_ids):
self._remove_packages(allowDeps, autoremove, package_ids)
def simulate_remove_packages(self, package_ids):
return self._remove_packages(False, False, package_ids, simulate=True)
@ConaryExceptionHandler
def _remove_packages(self,
allowDeps,
autoremove,
package_ids,
simulate=False):
# TODO: use autoremove
self.allow_cancel(False)
self.percentage(0)
self.status(STATUS_RUNNING)
pkglist = _get_trovespec_from_ids(package_ids)
cb = RemoveCallback(self, self.cfg)
updJob, suggMap = self.conary.erase(pkglist, cb, simulate)
if simulate:
pkgs = self._get_package_name_from_ids(package_ids)
installs, erases, updates = conarypk.parse_jobs(
updJob, excludes=pkgs, show_components=False)
self._display_update_jobs(installs, erases, updates)
def _check_for_reboot(self, name):
if name in self.rebootpkgs:
self.require_restart(RESTART_SYSTEM, "")
def get_update_detail(self, package_ids):
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_INFO)
for package_id in package_ids:
name, version, arch, label = split_package_id(package_id)
pkgDict = self.xmlcache.resolve(name)
update = ""
obsolete = ""
cve_url = ""
if pkgDict:
vendor_url = pkgDict.get("url", "")
desc = pkgDict.get("longDesc", "")
reboot = self._get_restart(name)
state = _get_branch(label)
bz_url = _get_fits(label)
self.update_detail(package_id,
update,
obsolete,
vendor_url,
bz_url,
cve_url,
reboot,
desc,
changelog="",
state=state,
issued="",
updated="")
def get_details(self, package_ids):
'''
Print a detailed description for a given package
'''
self.allow_cancel(True)
self.percentage(None)
self.status(STATUS_INFO)
for package_id in package_ids:
name, version, arch, data = split_package_id(package_id)
pkgDict = self.xmlcache.resolve(name)
if name and pkgDict:
longDesc = ""
url = ""
categories = None
licenses = ""
longDesc = pkgDict.get("longDesc", "")
url = pkgDict.get("url", "")
categories = self.xmlcache.getGroup(pkgDict.get(
"category", ""))
licenses = _get_license(pkgDict.get("licenses", ""))
size = pkgDict.get("size", 0)
self.details(package_id, '', licenses, categories, longDesc,
url, size)
def _get_restart(self, name):
if name in self.rebootpkgs:
return RESTART_SYSTEM
elif name in self.restartpkgs:
return RESTART_APPLICATION
else:
return RESTART_NONE
def _get_update_priority(self, name):
if name in self.rebootpkgs:
return INFO_SECURITY
elif name in self.restartpkgs:
return INFO_SECURITY
else:
return INFO_NORMAL
def _display_updates(self, jobs):
'''Emit Package signals for a list of update jobs
jobs should only contain installs and updates. Shouldn't get any erase
jobs.
'''
ret = []
for (name, (oldVer, oldFla), (newVer, newFla)) in jobs:
info = self._get_update_priority(name)
ret.append((name, newVer, newFla, info))
pkgs = [(self._convert_package((n, v, f), {}), info)
for (n, v, f, info) in ret]
self._show_package_list(pkgs)
@ConaryExceptionHandler
def get_updates(self, filters):
self.allow_cancel(True)
self.percentage(0)
self.status(STATUS_INFO)
cb = GetUpdateCallback(self, self.cfg)
updJob, suggMap = self.conary.updateall(cb, dry_run=True)
installs, erases, updates = conarypk.parse_jobs(updJob,
show_components=False)
self._display_updates(installs + updates)
def get_repo_list(self, filters):
labels = self.conary.get_labels()
self.status(STATUS_QUERY)
for repo in labels:
self.repo_detail(repo, repo, True)
def refresh_cache(self):
#log.debug("refresh-cache command ")
self.percentage()
self.status(STATUS_REFRESH_CACHE)
cache = Cache()
cache.refresh()
def refresh_cache(self, force):
self.percentage(None)
self.status(STATUS_REFRESH_CACHE)
cache = Cache()
cache.refresh()
