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 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: