EVOLUTION-MANAGER

Edit File: yumcommands.py

#!/usr/bin/python -t # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # Copyright 2006 Duke University # Copyright 2013 Red Hat # Written by Seth Vidal """ Classes for subcommands of the yum command line interface. """ import os import sys import cli import rpm from yum import logginglevels from yum import _, P_ from yum import misc import yum.Errors import operator import locale import fnmatch import time from yum.i18n import utf8_width, utf8_width_fill, to_unicode, exception2msg import tempfile import shutil import distutils.spawn import glob import errno import yum.config from yum import updateinfo from yum.packages import parsePackages from yum.fssnapshots import LibLVMError, lvmerr2str def _err_mini_usage(base, basecmd): if basecmd not in base.yum_cli_commands: base.usage() return cmd = base.yum_cli_commands[basecmd] txt = base.yum_cli_commands["help"]._makeOutput(cmd) base.logger.critical(_(' Mini usage:\n')) base.logger.critical(txt) def checkRootUID(base): """Verify that the program is being run by the root user. :param base: a :class:`yum.Yumbase` object. :raises: :class:`cli.CliError` """ if base.conf.uid != 0: base.logger.critical(_('You need to be root to perform this command.')) raise cli.CliError def checkGPGKey(base): """Verify that there are gpg keys for the enabled repositories in the rpm database. :param base: a :class:`yum.Yumbase` object. :raises: :class:`cli.CliError` """ if base._override_sigchecks: return if not base.gpgKeyCheck(): for repo in base.repos.listEnabled(): if (repo.gpgcheck or repo.repo_gpgcheck) and not repo.gpgkey: msg = _(""" You have enabled checking of packages via GPG keys. This is a good thing. However, you do not have any GPG public keys installed. You need to download the keys for packages you wish to install and install them. You can do that by running the command: rpm --import public.gpg.key Alternatively you can specify the url to the key you would like to use for a repository in the 'gpgkey' option in a repository section and yum will install it for you. For more information contact your distribution or package provider. """) base.logger.critical(msg) base.logger.critical(_("Problem repository: %s"), repo) raise cli.CliError def checkPackageArg(base, basecmd, extcmds): """Verify that *extcmds* contains the name of at least one package for *basecmd* to act on. :param base: a :class:`yum.Yumbase` object. :param basecmd: the name of the command being checked for :param extcmds: a list of arguments passed to *basecmd* :raises: :class:`cli.CliError` """ if len(extcmds) == 0: base.logger.critical( _('Error: Need to pass a list of pkgs to %s') % basecmd) _err_mini_usage(base, basecmd) raise cli.CliError def checkSwapPackageArg(base, basecmd, extcmds): """Verify that *extcmds* contains the name of at least two packages for *basecmd* to act on. :param base: a :class:`yum.Yumbase` object. :param basecmd: the name of the command being checked for :param extcmds: a list of arguments passed to *basecmd* :raises: :class:`cli.CliError` """ min_args = 2 if '--' in extcmds: min_args = 3 if len(extcmds) < min_args: base.logger.critical( _('Error: Need at least two packages to %s') % basecmd) _err_mini_usage(base, basecmd) raise cli.CliError def checkRepoPackageArg(base, basecmd, extcmds): """Verify that *extcmds* contains the name of at least one package for *basecmd* to act on. :param base: a :class:`yum.Yumbase` object. :param basecmd: the name of the command being checked for :param extcmds: a list of arguments passed to *basecmd* :raises: :class:`cli.CliError` """ if len(extcmds) < 2: # <repoid> install|remove [pkgs] base.logger.critical( _('Error: Need to pass a repoid. and command to %s') % basecmd) _err_mini_usage(base, basecmd) raise cli.CliError repos = base.repos.findRepos(extcmds[0], name_match=True, ignore_case=True) if not repos: base.logger.critical( _('Error: Need to pass a single valid repoid. to %s') % basecmd) _err_mini_usage(base, basecmd) raise cli.CliError if len(repos) > 1: repos = [r for r in repos if r.isEnabled()] if len(repos) > 1: repos = ", ".join([r.ui_id for r in repos]) base.logger.critical( _('Error: Need to pass only a single valid repoid. to %s, passed: %s') % (basecmd, repos)) _err_mini_usage(base, basecmd) raise cli.CliError if not repos[0].isEnabled(): # Might as well just fix this... base.repos.enableRepo(repos[0].id) base.verbose_logger.info( _('Repo %s has been automatically enabled.') % repos[0].ui_id) def checkItemArg(base, basecmd, extcmds): """Verify that *extcmds* contains the name of at least one item for *basecmd* to act on. Generally, the items are command-line arguments that are not the name of a package, such as a file name passed to provides. :param base: a :class:`yum.Yumbase` object. :param basecmd: the name of the command being checked for :param extcmds: a list of arguments passed to *basecmd* :raises: :class:`cli.CliError` """ if len(extcmds) == 0: base.logger.critical(_('Error: Need an item to match')) _err_mini_usage(base, basecmd) raise cli.CliError def checkGroupArg(base, basecmd, extcmds): """Verify that *extcmds* contains the name of at least one group for *basecmd* to act on. :param base: a :class:`yum.Yumbase` object. :param basecmd: the name of the command being checked for :param extcmds: a list of arguments passed to *basecmd* :raises: :class:`cli.CliError` """ if len(extcmds) == 0: base.logger.critical(_('Error: Need a group or list of groups')) _err_mini_usage(base, basecmd) raise cli.CliError def checkCleanArg(base, basecmd, extcmds): """Verify that *extcmds* contains at least one argument, and that all arguments in *extcmds* are valid options for clean. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command being checked for :param extcmds: a list of arguments passed to *basecmd* :raises: :class:`cli.CliError` """ VALID_ARGS = ('headers', 'packages', 'metadata', 'dbcache', 'plugins', 'expire-cache', 'rpmdb', 'all') if len(extcmds) == 0: base.logger.critical(_('Error: clean requires an option: %s') % ( ", ".join(VALID_ARGS))) raise cli.CliError for cmd in extcmds: if cmd not in VALID_ARGS: base.logger.critical(_('Error: invalid clean argument: %r') % cmd) _err_mini_usage(base, basecmd) raise cli.CliError def checkShellArg(base, basecmd, extcmds): """Verify that the arguments given to 'yum shell' are valid. yum shell can be given either no argument, or exactly one argument, which is the name of a file. :param base: a :class:`yum.Yumbase` object. :param basecmd: the name of the command being checked for :param extcmds: a list of arguments passed to *basecmd* :raises: :class:`cli.CliError` """ if len(extcmds) == 0: base.verbose_logger.debug(_("No argument to shell")) elif len(extcmds) == 1: base.verbose_logger.debug(_("Filename passed to shell: %s"), extcmds[0]) if not os.path.isfile(extcmds[0]): base.logger.critical( _("File %s given as argument to shell does not exist."), extcmds[0]) base.usage() raise cli.CliError else: base.logger.critical( _("Error: more than one file given as argument to shell.")) base.usage() raise cli.CliError def checkEnabledRepo(base, possible_local_files=[]): """Verify that there is at least one enabled repo. :param base: a :class:`yum.Yumbase` object. :param basecmd: the name of the command being checked for :param extcmds: a list of arguments passed to *basecmd* :raises: :class:`cli.CliError`: """ if base.repos.listEnabled(): return for lfile in possible_local_files: if lfile.endswith(".rpm") and (yum.misc.re_remote_url(lfile) or os.path.exists(lfile)): return # runs prereposetup (which "most" plugins currently use to add repos.) base.pkgSack if base.repos.listEnabled(): return msg = _('There are no enabled repos.\n' ' Run "yum repolist all" to see the repos you have.\n' ' To enable Red Hat Subscription Management repositories:\n' ' subscription-manager repos --enable <repo>\n' ' To enable custom repositories:\n' ' yum-config-manager --enable <repo>') base.logger.critical(msg) raise cli.CliError class YumCommand: """An abstract base class that defines the methods needed by the cli to execute a specific command. Subclasses must override at least :func:`getUsage` and :func:`getSummary`. """ def __init__(self): self.done_command_once = False self.hidden = False def doneCommand(self, base, msg, *args): """ Output *msg* the first time that this method is called, and do nothing on subsequent calls. This is to prevent duplicate messages from being printed for the same command. :param base: a :class:`yum.Yumbase` object :param msg: the message to be output :param *args: additional arguments associated with the message """ if not self.done_command_once: base.verbose_logger.info(logginglevels.INFO_2, msg, *args) self.done_command_once = True def getNames(self): """Return a list of strings that are the names of the command. The command can be called from the command line by using any of these names. :return: a list containing the names of the command """ return [] def getUsage(self): """Return a usage string for the command, including arguments. :return: a usage string for the command """ raise NotImplementedError def getSummary(self): """Return a one line summary of what the command does. :return: a one line summary of what the command does """ raise NotImplementedError def doCheck(self, base, basecmd, extcmds): """Verify that various conditions are met so that the command can run. :param base: a :class:`yum.Yumbase` object. :param basecmd: the name of the command being checked for :param extcmds: a list of arguments passed to *basecmd* """ pass def doCommand(self, base, basecmd, extcmds): """Execute the command :param base: a :class:`yum.Yumbase` object. :param basecmd: the name of the command being executed :param extcmds: a list of arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ return 0, [_('Nothing to do')] def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before the command can run :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ return True # Some of this is subjective, esp. between past/present, but roughly use: # # write = I'm using package data to alter the rpmdb in anyway. # read-only:future = I'm providing data that is likely to result in a # future write, so we might as well do it now. # Eg. yum check-update && yum update -q -y # read-only:present = I'm providing data about the present state of # packages in the repo. # Eg. yum list yum # read-only:past = I'm providing context data about past writes, or just # anything that is available is good enough for me # (speed is much better than quality). # Eg. yum history info # Eg. TAB completion # # ...default is write, which does the same thing we always did (obey # metadata_expire and live with it). def cacheRequirement(self, base, basecmd, extcmds): """Return the cache requirements for the remote repos. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: Type of requirement: read-only:past, read-only:present, read-only:future, write """ return 'write' class InstallCommand(YumCommand): """A class containing methods needed by the cli to execute the install command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['install', 'install-n', 'install-na', 'install-nevra'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return _("PACKAGE...") def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Install a package or packages on your system") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run. These include that the program is being run by the root user, that there are enabled repositories with gpg keys, and that this command is called with appropriate arguments. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkRootUID(base) checkGPGKey(base) checkPackageArg(base, basecmd, extcmds) checkEnabledRepo(base, extcmds) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ self.doneCommand(base, _("Setting up Install Process")) return base.installPkgs(extcmds, basecmd=basecmd) class UpdateCommand(YumCommand): """A class containing methods needed by the cli to execute the update command. """ def getNames(self): """Return a list containing the names of this command. This command can by called from the command line by using any of these names. :return: a list containing the names of this command """ return ['update', 'update-to'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return _("[PACKAGE...]") def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Update a package or packages on your system") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run. These include that there are enabled repositories with gpg keys, and that this command is being run by the root user. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkRootUID(base) checkGPGKey(base) checkEnabledRepo(base, extcmds) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ self.doneCommand(base, _("Setting up Update Process")) ret = base.updatePkgs(extcmds, update_to=(basecmd == 'update-to')) updateinfo.remove_txmbrs(base) return ret class DistroSyncCommand(YumCommand): """A class containing methods needed by the cli to execute the distro-synch command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['distribution-synchronization', 'distro-sync', 'distupgrade'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return _("[PACKAGE...]") def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Synchronize installed packages to the latest available versions") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run. These include that the program is being run by the root user, and that there are enabled repositories with gpg keys. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkRootUID(base) checkGPGKey(base) checkEnabledRepo(base, extcmds) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ self.doneCommand(base, _("Setting up Distribution Synchronization Process")) base.conf.obsoletes = 1 ret = base.distroSyncPkgs(extcmds) updateinfo.remove_txmbrs(base) return ret def _add_pkg_simple_list_lens(data, pkg, indent=''): """ Get the length of each pkg's column. Add that to data. This "knows" about simpleList and printVer. """ na = len(pkg.name) + 1 + len(pkg.arch) + len(indent) ver = len(pkg.version) + 1 + len(pkg.release) rid = len(pkg.ui_from_repo) if pkg.epoch != '0': ver += len(pkg.epoch) + 1 for (d, v) in (('na', na), ('ver', ver), ('rid', rid)): data[d].setdefault(v, 0) data[d][v] += 1 def _list_cmd_calc_columns(base, ypl): """ Work out the dynamic size of the columns to pass to fmtColumns. """ data = {'na' : {}, 'ver' : {}, 'rid' : {}} for lst in (ypl.installed, ypl.available, ypl.extras, ypl.updates, ypl.recent): for pkg in lst: _add_pkg_simple_list_lens(data, pkg) if len(ypl.obsoletes) > 0: for (npkg, opkg) in ypl.obsoletesTuples: _add_pkg_simple_list_lens(data, npkg) _add_pkg_simple_list_lens(data, opkg, indent=" " * 4) data = [data['na'], data['ver'], data['rid']] columns = base.calcColumns(data, remainder_column=1) return (-columns[0], -columns[1], -columns[2]) def _cmdline_exclude(pkgs, cmdline_excludes): """ Do an extra exclude for installed packages that match the cmd line. """ if not cmdline_excludes: return pkgs e,m,u = parsePackages(pkgs, cmdline_excludes) excluded = set(e + m) return [po for po in pkgs if po not in excluded] class InfoCommand(YumCommand): """A class containing methods needed by the cli to execute the info command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['info'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "[PACKAGE|all|available|installed|updates|distro-extras|extras|obsoletes|recent]" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Display details about a package or group of packages") def doCommand(self, base, basecmd, extcmds, repoid=None): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ if extcmds and extcmds[0] in ('updates', 'obsoletes'): updateinfo.exclude_updates(base) else: updateinfo.exclude_all(base) if True: # Try, YumBase... highlight = base.term.MODE['bold'] # If we are doing: "yum info installed blah" don't do the highlight # because the usability of not accessing the repos. is still higher # than providing colour for a single line. Usable updatesd/etc. FTW. if basecmd == 'info' and extcmds and extcmds[0] == 'installed': highlight = False ypl = base.returnPkgLists(extcmds, installed_available=highlight, repoid=repoid) update_pkgs = {} inst_pkgs = {} local_pkgs = {} columns = None if basecmd == 'list': # Dynamically size the columns columns = _list_cmd_calc_columns(base, ypl) if highlight and ypl.installed: # If we have installed and available lists, then do the # highlighting for the installed packages so you can see what's # available to update, an extra, or newer than what we have. for pkg in (ypl.hidden_available + ypl.reinstall_available + ypl.old_available): key = (pkg.name, pkg.arch) if key not in update_pkgs or pkg.verGT(update_pkgs[key]): update_pkgs[key] = pkg if highlight and ypl.available: # If we have installed and available lists, then do the # highlighting for the available packages so you can see what's # available to install vs. update vs. old. for pkg in ypl.hidden_installed: key = (pkg.name, pkg.arch) if key not in inst_pkgs or pkg.verGT(inst_pkgs[key]): inst_pkgs[key] = pkg if highlight and ypl.updates: # Do the local/remote split we get in "yum updates" for po in sorted(ypl.updates): if po.repo.id != 'installed' and po.verifyLocalPkg(): local_pkgs[(po.name, po.arch)] = po # Output the packages: kern = base.conf.color_list_installed_running_kernel clio = base.conf.color_list_installed_older clin = base.conf.color_list_installed_newer clir = base.conf.color_list_installed_reinstall clie = base.conf.color_list_installed_extra if base.conf.query_install_excludes: ypl.installed = _cmdline_exclude(ypl.installed, base.cmdline_excludes) rip = base.listPkgs(ypl.installed, _('Installed Packages'), basecmd, highlight_na=update_pkgs, columns=columns, highlight_modes={'>' : clio, '<' : clin, 'kern' : kern, '=' : clir, 'not in' : clie}) kern = base.conf.color_list_available_running_kernel clau = base.conf.color_list_available_upgrade clad = base.conf.color_list_available_downgrade clar = base.conf.color_list_available_reinstall clai = base.conf.color_list_available_install rap = base.listPkgs(ypl.available, _('Available Packages'), basecmd, highlight_na=inst_pkgs, columns=columns, highlight_modes={'<' : clau, '>' : clad, 'kern' : kern, '=' : clar, 'not in' : clai}) rep = base.listPkgs(ypl.extras, _('Extra Packages'), basecmd, columns=columns) cul = base.conf.color_update_local cur = base.conf.color_update_remote rup = base.listPkgs(ypl.updates, _('Updated Packages'), basecmd, highlight_na=local_pkgs, columns=columns, highlight_modes={'=' : cul, 'not in' : cur}) # XXX put this into the ListCommand at some point if len(ypl.obsoletes) > 0 and basecmd == 'list': # if we've looked up obsolete lists and it's a list request rop = [0, ''] print _('Obsoleting Packages') # The tuple is (newPkg, oldPkg) ... so sort by new for obtup in sorted(ypl.obsoletesTuples, key=operator.itemgetter(0)): base.updatesObsoletesList(obtup, 'obsoletes', columns=columns, repoid=repoid) else: rop = base.listPkgs(ypl.obsoletes, _('Obsoleting Packages'), basecmd, columns=columns) rrap = base.listPkgs(ypl.recent, _('Recently Added Packages'), basecmd, columns=columns) # extcmds is pop(0)'d if they pass a "special" param like "updates" # in returnPkgLists(). This allows us to always return "ok" for # things like "yum list updates". if len(extcmds) and \ rrap[0] and rop[0] and rup[0] and rep[0] and rap[0] and rip[0]: return 1, [_('No matching Packages to list')] return 0, [] def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ if len(extcmds) and extcmds[0] == 'installed': return False return True def cacheRequirement(self, base, basecmd, extcmds): """Return the cache requirements for the remote repos. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: Type of requirement: read-only:past, read-only:present, read-only:future, write """ if len(extcmds) and extcmds[0] in ('updates', 'obsoletes'): return 'read-only:future' if len(extcmds) and extcmds[0] in ('installed', 'distro-extras', 'extras', 'recent'): return 'read-only:past' # available/all return 'read-only:present' class ListCommand(InfoCommand): """A class containing methods needed by the cli to execute the list command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['list'] def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("List a package or groups of packages") class EraseCommand(YumCommand): """A class containing methods needed by the cli to execute the erase command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['erase', 'remove', 'autoremove', 'erase-n', 'erase-na', 'erase-nevra', 'autoremove-n', 'autoremove-na', 'autoremove-nevra', 'remove-n', 'remove-na', 'remove-nevra'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "PACKAGE..." def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Remove a package or packages from your system") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run. These include that the program is being run by the root user, and that this command is called with appropriate arguments. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkRootUID(base) if basecmd == 'autoremove': return checkPackageArg(base, basecmd, extcmds) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ pos = False if basecmd.startswith('autoremove'): # We have to alter this, as it's used in resolving stage. Which # sucks. Just be careful in "yum shell". base.conf.clean_requirements_on_remove = True basecmd = basecmd[len('auto'):] # pretend it's just remove... if not extcmds: pos = True extcmds = [] for pkg in sorted(base.rpmdb.returnLeafNodes()): if 'reason' not in pkg.yumdb_info: continue if pkg.yumdb_info.reason != 'dep': continue extcmds.append(pkg) self.doneCommand(base, _("Setting up Remove Process")) ret = base.erasePkgs(extcmds, pos=pos, basecmd=basecmd) return ret def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ return False def needTsRemove(self, base, basecmd, extcmds): """Return whether a transaction set for removal only must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a remove-only transaction set is needed, False otherwise """ return True class GroupsCommand(YumCommand): """ Single sub-command interface for most groups interaction. """ direct_commands = {'grouplist' : 'list', 'groupinstall' : 'install', 'groupupdate' : 'update', 'groupremove' : 'remove', 'grouperase' : 'remove', 'groupinfo' : 'info'} def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['groups', 'group'] + self.direct_commands.keys() def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "[list|info|summary|install|upgrade|remove|mark] [GROUP]" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Display, or use, the groups information") def _grp_setup_doCommand(self, base): self.doneCommand(base, _("Setting up Group Process")) base.doRepoSetup(dosack=0) try: base.doGroupSetup() except yum.Errors.GroupsError: return 1, [_('No Groups on which to run command')] except yum.Errors.YumBaseError, e: raise def _grp_cmd(self, basecmd, extcmds): if basecmd in self.direct_commands: cmd = self.direct_commands[basecmd] elif extcmds: cmd = extcmds[0] extcmds = extcmds[1:] else: cmd = 'summary' if cmd in ('mark', 'unmark') and extcmds: cmd = "%s-%s" % (cmd, extcmds[0]) extcmds = extcmds[1:] remap = {'update' : 'upgrade', 'erase' : 'remove', 'mark-erase' : 'mark-remove', } cmd = remap.get(cmd, cmd) return cmd, extcmds def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run. The exact conditions checked will vary depending on the subcommand that is being called. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ cmd, extcmds = self._grp_cmd(basecmd, extcmds) checkEnabledRepo(base) ocmds_all = [] ocmds_arg = [] if base.conf.group_command == 'objects': ocmds_arg = ('mark-install', 'mark-remove', 'mark-blacklist', 'mark-packages', 'mark-packages-force', 'unmark-packages', 'mark-packages-sync', 'mark-packages-sync-force', 'mark-groups', 'mark-groups-force', 'unmark-groups', 'mark-groups-sync', 'mark-groups-sync-force') ocmds_all = ('mark-install', 'mark-remove', 'mark-convert', 'mark-convert-whitelist', 'mark-convert-blacklist', 'mark-blacklist', 'mark-packages', 'mark-packages-force', 'unmark-packages', 'mark-packages-sync', 'mark-packages-sync-force', 'mark-groups', 'mark-groups-force', 'unmark-groups', 'mark-groups-sync', 'mark-groups-sync-force') if cmd in ('install', 'remove', 'info') or cmd in ocmds_arg: checkGroupArg(base, cmd, extcmds) if cmd in ('install', 'remove', 'upgrade') or cmd in ocmds_all: checkRootUID(base) if cmd in ('install', 'upgrade'): checkGPGKey(base) cmds = set(('list', 'info', 'remove', 'install', 'upgrade', 'summary')) if base.conf.group_command == 'objects': cmds.update(ocmds_all) if cmd not in cmds: base.logger.critical(_('Invalid groups sub-command, use: %s.'), ", ".join(cmds)) raise cli.CliError if base.conf.group_command != 'objects': pass elif not os.path.exists(os.path.dirname(base.igroups.filename)): base.logger.critical(_("There is no installed groups file.")) base.logger.critical(_("Maybe run: yum groups mark convert (see man yum)")) elif not os.access(os.path.dirname(base.igroups.filename), os.R_OK): base.logger.critical(_("You don't have access to the groups DBs.")) raise cli.CliError elif not os.path.exists(base.igroups.filename): base.logger.critical(_("There is no installed groups file.")) base.logger.critical(_("Maybe run: yum groups mark convert (see man yum)")) elif not os.access(base.igroups.filename, os.R_OK): base.logger.critical(_("You don't have access to the groups DB.")) raise cli.CliError def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ cmd, extcmds = self._grp_cmd(basecmd, extcmds) self._grp_setup_doCommand(base) if cmd == 'summary': return base.returnGroupSummary(extcmds) if cmd == 'list': return base.returnGroupLists(extcmds) if True: # Try, YumBase... if cmd == 'info': return base.returnGroupInfo(extcmds) if cmd == 'install': return base.installGroups(extcmds) if cmd == 'upgrade': ret = base.installGroups(extcmds, upgrade=True) updateinfo.remove_txmbrs(base) return ret if cmd == 'remove': return base.removeGroups(extcmds) if cmd == 'mark-install': gRG = base._groupReturnGroups(extcmds,ignore_case=False) igrps, grps, ievgrps, evgrps = gRG for evgrp in evgrps: base.igroups.add_environment(evgrp.environmentid, evgrp.allgroups) for grp in grps: pkg_names = set() # Only see names that are installed. for pkg in base.rpmdb.searchNames(grp.packages): pkg_names.add(pkg.name) base.igroups.add_group(grp.groupid, pkg_names) base.igroups.save() return 0, ['Marked install: ' + ','.join(extcmds)] if cmd == 'mark-blacklist': gRG = base._groupReturnGroups(extcmds,ignore_case=False) igrps, grps, ievgrps, evgrps = gRG for ievgrp in ievgrps: evgrp = base.comps.return_environment(igrp.evgid) if not evgrp: continue base.igroups.changed = True ievgrp.grp_names.update(grp.groups) for igrp in igrps: grp = base.comps.return_group(igrp.gid) if not grp: continue base.igroups.changed = True igrp.pkg_names.update(grp.packages) base.igroups.save() return 0, ['Marked upgrade blacklist: ' + ','.join(extcmds)] if cmd in ('mark-packages', 'mark-packages-force'): if len(extcmds) < 2: return 1, ['No group or package given'] gRG = base._groupReturnGroups([extcmds[0]], ignore_case=False) igrps, grps, ievgrps, evgrps = gRG if igrps is None or len(igrps) != 1: return 1, ['No group matched'] grp = igrps[0] force = cmd == 'mark-packages-force' for pkg in base.rpmdb.returnPackages(patterns=extcmds[1:]): if not force and 'group_member' in pkg.yumdb_info: continue pkg.yumdb_info.group_member = grp.gid grp.pkg_names.add(pkg.name) base.igroups.changed = True base.igroups.save() return 0, ['Marked packages: ' + ','.join(extcmds[1:])] if cmd == 'unmark-packages': for pkg in base.rpmdb.returnPackages(patterns=extcmds): if 'group_member' in pkg.yumdb_info: del pkg.yumdb_info.group_member return 0, ['UnMarked packages: ' + ','.join(extcmds)] if cmd in ('mark-packages-sync', 'mark-packages-sync-force'): gRG = base._groupReturnGroups(extcmds,ignore_case=False) igrps, grps, ievgrps, evgrps = gRG if not igrps: return 1, ['No group matched'] force = cmd == 'mark-packages-sync-force' for grp in igrps: for pkg in base.rpmdb.searchNames(grp.pkg_names): if not force and 'group_member' in pkg.yumdb_info: continue pkg.yumdb_info.group_member = grp.gid if force: return 0, ['Marked packages-sync-force: '+','.join(extcmds)] else: return 0, ['Marked packages-sync: ' + ','.join(extcmds)] if cmd in ('mark-groups', 'mark-groups-force'): if len(extcmds) < 2: return 1, ['No environment or group given'] gRG = base._groupReturnGroups([extcmds[0]], ignore_case=False) igrps, grps, ievgrps, evgrps = gRG if ievgrps is None or len(ievgrps) != 1: return 1, ['No environment matched'] evgrp = ievgrps[0] force = cmd == 'mark-groups-force' gRG = base._groupReturnGroups(extcmds[1:], ignore_case=False) for grp in gRG[1]: # Packages full or empty? self.igroups.add_group(grp.groupid, grp.packages, ievgrp) if force: for grp in gRG[0]: grp.environment = evgrp.evgid base.igroups.changed = True base.igroups.save() return 0, ['Marked groups: ' + ','.join(extcmds[1:])] if cmd == 'unmark-groups': gRG = base._groupReturnGroups([extcmds[0]], ignore_case=False) igrps, grps, ievgrps, evgrps = gRG if igrps is None: return 1, ['No groups matched'] for grp in igrps: grp.environment = None base.igroups.changed = True base.igroups.save() return 0, ['UnMarked groups: ' + ','.join(extcmds)] if cmd in ('mark-groups-sync', 'mark-groups-sync-force'): gRG = base._groupReturnGroups(extcmds,ignore_case=False) igrps, grps, ievgrps, evgrps = gRG if not ievgrps: return 1, ['No environment matched'] force = cmd == 'mark-groups-sync-force' for evgrp in ievgrps: grp_names = ",".join(sorted(evgrp.grp_names)) for grp in base.igroups.return_groups(grp_names): if not force and grp.environment is not None: continue grp.environment = evgrp.evgid base.igroups.changed = True base.igroups.save() if force: return 0, ['Marked groups-sync-force: '+','.join(extcmds)] else: return 0, ['Marked groups-sync: ' + ','.join(extcmds)] # FIXME: This doesn't do environment groups atm. if cmd in ('mark-convert', 'mark-convert-whitelist', 'mark-convert-blacklist'): # Convert old style info. into groups as objects. def _convert_grp(grp): if not grp.installed: return pkg_names = [] for pkg in base.rpmdb.searchNames(grp.packages): if 'group_member' in pkg.yumdb_info: continue pkg.yumdb_info.group_member = grp.groupid pkg_names.append(pkg.name) # We only mark the packages installed as a known part of # the group. This way "group update" will work and install # any remaining packages, as it would before the conversion. if cmd == 'mark-convert-whitelist': base.igroups.add_group(grp.groupid, pkg_names) else: base.igroups.add_group(grp.groupid, grp.packages) # Blank everything. for gid in base.igroups.groups.keys(): base.igroups.del_group(gid) for pkg in base.rpmdb: if 'group_member' in pkg.yumdb_info: del pkg.yumdb_info.group_member # Need to do this by hand, when using objects, to setup the # .installed attribute in comps. base.comps.compile(base.rpmdb.simplePkgList()) # This is kind of a hack, to work around the biggest problem # with having pkgs in more than one group. Treat Fedora/EL/etc. # base/core special. Maybe other groups? # Not 100% we want to force install "core", as that's then # "different", but it is better ... so, meh. special_gids = (('core', True), ('base', False)) for gid, force_installed in special_gids: grp = base.comps.return_group(gid) if grp is None: continue if force_installed: grp.installed = True _convert_grp(grp) for grp in base.comps.get_groups(): if grp.groupid in special_gids: continue _convert_grp(grp) base.igroups.save() return 0, ['Converted old style groups to objects.'] if cmd == 'mark-remove': gRG = base._groupReturnGroups(extcmds,ignore_case=False) igrps, grps, ievgrps, evgrps = gRG for evgrp in ievgrps: base.igroups.del_environment(evgrp.evgid) for grp in igrps: base.igroups.del_group(grp.gid) base.igroups.save() return 0, ['Marked remove: ' + ','.join(extcmds)] def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ cmd, extcmds = self._grp_cmd(basecmd, extcmds) if cmd in ('list', 'info', 'remove', 'summary'): return False if cmd.startswith('mark') or cmd.startswith('unmark'): return False return True def needTsRemove(self, base, basecmd, extcmds): """Return whether a transaction set for removal only must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a remove-only transaction set is needed, False otherwise """ cmd, extcmds = self._grp_cmd(basecmd, extcmds) if cmd in ('remove',): return True return False def cacheRequirement(self, base, basecmd, extcmds): """Return the cache requirements for the remote repos. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: Type of requirement: read-only:past, read-only:present, read-only:future, write """ cmd, extcmds = self._grp_cmd(basecmd, extcmds) if cmd in ('list', 'info', 'summary'): return 'read-only:past' if cmd.startswith('mark') or cmd.startswith('unmark'): return 'read-only:past' return 'write' class MakeCacheCommand(YumCommand): """A class containing methods needed by the cli to execute the makecache command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['makecache'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Generate the metadata cache") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run; namely that there is an enabled repository. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkEnabledRepo(base) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ base.logger.debug(_("Making cache files for all metadata files.")) base.logger.debug(_("This may take a while depending on the speed of this computer")) # Fast == don't download any extra MD fast = False if extcmds and extcmds[0] == 'fast': fast = True if True: # Try, YumBase... for repo in base.repos.sort(): repo.metadata_expire = 0 if not fast: repo.mdpolicy = "group:all" base.doRepoSetup(dosack=0) base.repos.doSetup() # These convert the downloaded data into usable data, # we can't remove them until *LoadRepo() can do: # 1. Download a .sqlite.bz2 and convert to .sqlite # 2. Download a .xml.gz and convert to .xml.gz.sqlite if fast: # Can't easily tell which other metadata each repo. has, so # just do primary. base.repos.populateSack(mdtype='metadata', cacheonly=1) else: base.repos.populateSack(mdtype='all', cacheonly=1) # Now decompress stuff, so that -C works, sigh. fname_map = {'group_gz' : 'groups.xml', 'pkgtags' : 'pkgtags.sqlite', 'updateinfo' : 'updateinfo.xml', 'prestodelta': 'prestodelta.xml', } for repo in base.repos.listEnabled(): for MD in repo.repoXML.fileTypes(): if MD not in fname_map: continue if MD not in repo.retrieved or not repo.retrieved[MD]: continue # For fast mode. misc.repo_gen_decompress(repo.retrieveMD(MD), fname_map[MD], cached=repo.cache) return 0, [_('Metadata Cache Created')] def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ return False class CleanCommand(YumCommand): """A class containing methods needed by the cli to execute the clean command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['clean'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "[headers|packages|metadata|dbcache|plugins|expire-cache|all]" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Remove cached data") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run. These include that there is at least one enabled repository, and that this command is called with appropriate arguments. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkCleanArg(base, basecmd, extcmds) checkEnabledRepo(base) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ base.conf.cache = 1 return base.cleanCli(extcmds) def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ return False def cacheRequirement(self, base, basecmd, extcmds): """Return the cache requirements for the remote repos. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: Type of requirement: read-only:past, read-only:present, read-only:future, write """ return 'read-only:past' class ProvidesCommand(YumCommand): """A class containing methods needed by the cli to execute the provides command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['provides', 'whatprovides'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "SOME_STRING" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Find what package provides the given value") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run; namely that this command is called with appropriate arguments. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkItemArg(base, basecmd, extcmds) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ base.logger.debug("Searching Packages: ") updateinfo.exclude_updates(base) return base.provides(extcmds) def cacheRequirement(self, base, basecmd, extcmds): """Return the cache requirements for the remote repos. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: Type of requirement: read-only:past, read-only:present, read-only:future, write """ return 'read-only:past' class CheckUpdateCommand(YumCommand): """A class containing methods needed by the cli to execute the check-update command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['check-update', 'check-updates', 'check-upgrade', 'check-upgrades'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "[PACKAGE...]" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Check for available package updates") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run; namely that there is at least one enabled repository. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkEnabledRepo(base) def doCommand(self, base, basecmd, extcmds, repoid=None): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ updateinfo.exclude_updates(base) obscmds = ['obsoletes'] + extcmds base.extcmds.insert(0, 'updates') result = 0 if True: ypl = base.returnPkgLists(extcmds, repoid=repoid) if (base.conf.obsoletes or base.verbose_logger.isEnabledFor(logginglevels.DEBUG_3)): typl = base.returnPkgLists(obscmds, repoid=repoid) ypl.obsoletes = typl.obsoletes ypl.obsoletesTuples = typl.obsoletesTuples columns = _list_cmd_calc_columns(base, ypl) if len(ypl.updates) > 0: local_pkgs = {} highlight = base.term.MODE['bold'] if highlight: # Do the local/remote split we get in "yum updates" for po in sorted(ypl.updates): if po.repo.id != 'installed' and po.verifyLocalPkg(): local_pkgs[(po.name, po.arch)] = po cul = base.conf.color_update_local cur = base.conf.color_update_remote base.listPkgs(ypl.updates, '', outputType='list', highlight_na=local_pkgs, columns=columns, highlight_modes={'=' : cul, 'not in' : cur}) result = 100 if len(ypl.obsoletes) > 0: # This only happens in verbose mode print _('Obsoleting Packages') # The tuple is (newPkg, oldPkg) ... so sort by new for obtup in sorted(ypl.obsoletesTuples, key=operator.itemgetter(0)): base.updatesObsoletesList(obtup, 'obsoletes', columns=columns, repoid=repoid) result = 100 # Add check_running_kernel call, if updateinfo is available. if (base.conf.autocheck_running_kernel and updateinfo._repos_downloaded(base.repos.listEnabled())): def _msg(x): base.verbose_logger.info("%s", x) updateinfo._check_running_kernel(base, base.upinfo, _msg) return result, [] def cacheRequirement(self, base, basecmd, extcmds): """Return the cache requirements for the remote repos. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: Type of requirement: read-only:past, read-only:present, read-only:future, write """ return 'read-only:future' class SearchCommand(YumCommand): """A class containing methods needed by the cli to execute the search command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['search'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "SOME_STRING" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Search package details for the given string") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run; namely that this command is called with appropriate arguments. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkItemArg(base, basecmd, extcmds) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ base.logger.debug(_("Searching Packages: ")) updateinfo.exclude_updates(base) return base.search(extcmds) def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ return False def cacheRequirement(self, base, basecmd, extcmds): """Return the cache requirements for the remote repos. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: Type of requirement: read-only:past, read-only:present, read-only:future, write """ return 'read-only:present' class UpgradeCommand(YumCommand): """A class containing methods needed by the cli to execute the upgrade command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['upgrade', 'upgrade-to'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return 'PACKAGE...' def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Update packages taking obsoletes into account") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run. These include that the program is being run by the root user, and that there are enabled repositories with gpg. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkRootUID(base) checkGPGKey(base) checkEnabledRepo(base, extcmds) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ base.conf.obsoletes = 1 self.doneCommand(base, _("Setting up Upgrade Process")) ret = base.updatePkgs(extcmds, update_to=(basecmd == 'upgrade-to')) updateinfo.remove_txmbrs(base) return ret class LocalInstallCommand(YumCommand): """A class containing methods needed by the cli to execute the localinstall command. """ def __init__(self): YumCommand.__init__(self) self.hidden = True def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['localinstall', 'localupdate'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "FILE" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Install a local RPM") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run. These include that there are enabled repositories with gpg keys, and that this command is called with appropriate arguments. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkRootUID(base) checkGPGKey(base) checkPackageArg(base, basecmd, extcmds) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ self.doneCommand(base, _("Setting up Local Package Process")) updateonly = basecmd == 'localupdate' return base.localInstall(filelist=extcmds, updateonly=updateonly) def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ return False class ResolveDepCommand(YumCommand): """A class containing methods needed by the cli to execute the resolvedep command. """ def __init__(self): YumCommand.__init__(self) self.hidden = True def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['resolvedep'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "DEPENDENCY" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return "repoquery --pkgnarrow=all --whatprovides --qf '%{envra} %{ui_from_repo}'" def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ base.logger.debug(_("Searching Packages for Dependency:")) updateinfo.exclude_updates(base) return base.resolveDepCli(extcmds) def cacheRequirement(self, base, basecmd, extcmds): """Return the cache requirements for the remote repos. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: Type of requirement: read-only:past, read-only:present, read-only:future, write """ return 'read-only:past' class ShellCommand(YumCommand): """A class containing methods needed by the cli to execute the shell command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['shell'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "[FILENAME]" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Run an interactive yum shell") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run; namely that this command is called with appropriate arguments. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkShellArg(base, basecmd, extcmds) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ self.doneCommand(base, _('Setting up Yum Shell')) return base.doShell() def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ return False class DepListCommand(YumCommand): """A class containing methods needed by the cli to execute the deplist command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['deplist'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return 'PACKAGE...' def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("List a package's dependencies") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run; namely that this command is called with appropriate arguments. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkPackageArg(base, basecmd, extcmds) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ self.doneCommand(base, _("Finding dependencies: ")) updateinfo.exclude_updates(base) return base.deplist(extcmds) def cacheRequirement(self, base, basecmd, extcmds): """Return the cache requirements for the remote repos. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: Type of requirement: read-only:past, read-only:present, read-only:future, write """ return 'read-only:past' # read-only ? class RepoListCommand(YumCommand): """A class containing methods needed by the cli to execute the repolist command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ('repolist', 'repoinfo') def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return '[all|enabled|disabled]' def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _('Display the configured software repositories') def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ def _repo_size(repo): ret = 0 for pkg in repo.sack.returnPackages(): ret += pkg.packagesize return base.format_number(ret) def _repo_match(repo, patterns): for pat in patterns: if repo in base.repos.findRepos(pat, name_match=True, ignore_case=True): return True return False def _num2ui_num(num): return to_unicode(locale.format("%d", num, True)) if len(extcmds) >= 1 and extcmds[0] in ('all', 'disabled', 'enabled'): arg = extcmds[0] extcmds = extcmds[1:] else: arg = 'enabled' extcmds = map(lambda x: x.lower(), extcmds) if basecmd == 'repoinfo': verbose = True else: verbose = base.verbose_logger.isEnabledFor(logginglevels.DEBUG_3) if arg != 'disabled' or extcmds: try: # Setup so len(repo.sack) is correct base.repos.populateSack() base.pkgSack # Need to setup the pkgSack, so excludes work except yum.Errors.RepoError: if verbose: raise # populate them by hand, so one failure doesn't kill everything # after it. for repo in base.repos.listEnabled(): try: base.repos.populateSack(repo.id) except yum.Errors.RepoError: pass repos = base.repos.repos.values() repos.sort() enabled_repos = base.repos.listEnabled() on_ehibeg = base.term.FG_COLOR['green'] + base.term.MODE['bold'] on_dhibeg = base.term.FG_COLOR['red'] on_hiend = base.term.MODE['normal'] tot_num = 0 cols = [] for repo in repos: if len(extcmds) and not _repo_match(repo, extcmds): continue (ehibeg, dhibeg, hiend) = '', '', '' ui_enabled = '' ui_endis_wid = 0 ui_num = "" ui_excludes_num = '' force_show = False if arg == 'all' or repo.id in extcmds or repo.name in extcmds: force_show = True (ehibeg, dhibeg, hiend) = (on_ehibeg, on_dhibeg, on_hiend) if repo in enabled_repos: enabled = True if arg == 'enabled': force_show = False elif arg == 'disabled' and not force_show: continue if force_show or verbose: ui_enabled = ehibeg + _('enabled') + hiend ui_endis_wid = utf8_width(_('enabled')) if not verbose: ui_enabled += ": " ui_endis_wid += 2 if verbose: ui_size = _repo_size(repo) # We don't show status for list disabled if arg != 'disabled' or verbose: if verbose or base.conf.exclude or repo.exclude: num = len(repo.sack.simplePkgList()) else: num = len(repo.sack) ui_num = _num2ui_num(num) excludes = repo.sack._excludes excludes = len([pid for r,pid in excludes if r == repo]) if excludes: ui_excludes_num = _num2ui_num(excludes) if not verbose: ui_num += "+%s" % ui_excludes_num tot_num += num else: enabled = False if arg == 'disabled': force_show = False elif arg == 'enabled' and not force_show: continue ui_enabled = dhibeg + _('disabled') + hiend ui_endis_wid = utf8_width(_('disabled')) if not verbose: rid = repo.ui_id # can't use str() if repo.metadata_expire >= 0: if os.path.exists(repo.metadata_cookie): last = os.stat(repo.metadata_cookie).st_mtime if last + repo.metadata_expire < time.time(): rid = '!' + rid if enabled and repo.metalink: mdts = repo.metalink_data.repomd.timestamp if mdts > repo.repoXML.timestamp: rid = '*' + rid cols.append((rid, repo.name, (ui_enabled, ui_endis_wid), ui_num)) else: if enabled: md = repo.repoXML else: md = None out = [base.fmtKeyValFill(_("Repo-id : "), repo.ui_id), base.fmtKeyValFill(_("Repo-name : "), repo.name)] if force_show or extcmds: out += [base.fmtKeyValFill(_("Repo-status : "), ui_enabled)] if md and md.revision is not None: out += [base.fmtKeyValFill(_("Repo-revision: "), md.revision)] if md and md.tags['content']: tags = md.tags['content'] out += [base.fmtKeyValFill(_("Repo-tags : "), ", ".join(sorted(tags)))] if md and md.tags['distro']: for distro in sorted(md.tags['distro']): tags = md.tags['distro'][distro] out += [base.fmtKeyValFill(_("Repo-distro-tags: "), "[%s]: %s" % (distro, ", ".join(sorted(tags))))] if md: out += [base.fmtKeyValFill(_("Repo-updated : "), time.ctime(md.timestamp)), base.fmtKeyValFill(_("Repo-pkgs : "),ui_num), base.fmtKeyValFill(_("Repo-size : "),ui_size)] if hasattr(repo, '_orig_baseurl'): baseurls = repo._orig_baseurl else: baseurls = repo.baseurl if baseurls: out += [base.fmtKeyValFill(_("Repo-baseurl : "), ", ".join(baseurls))] if enabled: # This needs to be here due to the mirrorlists are # metalinks hack. repo.urls if repo.metalink: out += [base.fmtKeyValFill(_("Repo-metalink: "), repo.metalink)] if enabled: ts = repo.metalink_data.repomd.timestamp out += [base.fmtKeyValFill(_(" Updated : "), time.ctime(ts))] elif repo.mirrorlist: out += [base.fmtKeyValFill(_("Repo-mirrors : "), repo.mirrorlist)] if enabled and repo.urls and not baseurls: url = repo.urls[0] if len(repo.urls) > 1: url += ' (%d more)' % (len(repo.urls) - 1) out += [base.fmtKeyValFill(_("Repo-baseurl : "), url)] if not os.path.exists(repo.metadata_cookie): last = _("Unknown") else: last = os.stat(repo.metadata_cookie).st_mtime last = time.ctime(last) if repo.metadata_expire <= -1: num = _("Never (last: %s)") % last elif not repo.metadata_expire: num = _("Instant (last: %s)") % last else: num = _num2ui_num(repo.metadata_expire) num = _("%s second(s) (last: %s)") % (num, last) out += [base.fmtKeyValFill(_("Repo-expire : "), num), base.fmtKeyValFill(_(" Filter : "), repo.metadata_expire_filter), ] if repo.exclude: out += [base.fmtKeyValFill(_("Repo-exclude : "), ", ".join(repo.exclude))] if repo.includepkgs: out += [base.fmtKeyValFill(_("Repo-include : "), ", ".join(repo.includepkgs))] if ui_excludes_num: out += [base.fmtKeyValFill(_("Repo-excluded: "), ui_excludes_num)] if repo.repofile: out += [base.fmtKeyValFill(_("Repo-filename: "), repo.repofile)] base.verbose_logger.info("%s\n", "\n".join(map(misc.to_unicode, out))) if not verbose and cols: # Work out the first (id) and last (enabled/disalbed/count), # then chop the middle (name)... id_len = utf8_width(_('repo id')) nm_len = 0 st_len = 0 ui_len = 0 for (rid, rname, (ui_enabled, ui_endis_wid), ui_num) in cols: if id_len < utf8_width(rid): id_len = utf8_width(rid) if nm_len < utf8_width(rname): nm_len = utf8_width(rname) if st_len < (ui_endis_wid + len(ui_num)): st_len = (ui_endis_wid + len(ui_num)) # Need this as well as above for: utf8_width_fill() if ui_len < len(ui_num): ui_len = len(ui_num) if arg == 'disabled': # Don't output a status column. left = base.term.columns - (id_len + 1) elif utf8_width(_('status')) > st_len: left = base.term.columns - (id_len + utf8_width(_('status')) +2) else: left = base.term.columns - (id_len + st_len + 2) if left < nm_len: # Name gets chopped nm_len = left else: # Share the extra... left -= nm_len id_len += left / 2 nm_len += left - (left / 2) txt_rid = utf8_width_fill(_('repo id'), id_len) txt_rnam = utf8_width_fill(_('repo name'), nm_len, nm_len) if arg == 'disabled': # Don't output a status column. base.verbose_logger.info("%s %s", txt_rid, txt_rnam) else: base.verbose_logger.info("%s %s %s", txt_rid, txt_rnam, _('status')) for (rid, rname, (ui_enabled, ui_endis_wid), ui_num) in cols: if arg == 'disabled': # Don't output a status column. base.verbose_logger.info("%s %s", utf8_width_fill(rid, id_len), utf8_width_fill(rname, nm_len, nm_len)) continue if ui_num: ui_num = utf8_width_fill(ui_num, ui_len, left=False) base.verbose_logger.info("%s %s %s%s", utf8_width_fill(rid, id_len), utf8_width_fill(rname, nm_len, nm_len), ui_enabled, ui_num) return 0, ['repolist: ' +to_unicode(locale.format("%d", tot_num, True))] def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ return False def cacheRequirement(self, base, basecmd, extcmds): """Return the cache requirements for the remote repos. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: Type of requirement: read-only:past, read-only:present, read-only:future, write """ return 'read-only:past' class HelpCommand(YumCommand): """A class containing methods needed by the cli to execute the help command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['help'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "COMMAND" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Display a helpful usage message") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run; namely that this command is called with appropriate arguments. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ if len(extcmds) == 0: base.usage() raise cli.CliError elif len(extcmds) > 1 or extcmds[0] not in base.yum_cli_commands: base.usage() raise cli.CliError @staticmethod def _makeOutput(command): canonical_name = command.getNames()[0] # Check for the methods in case we have plugins that don't # implement these. # XXX Remove this once usage/summary are common enough try: usage = command.getUsage() except (AttributeError, NotImplementedError): usage = None try: summary = command.getSummary() except (AttributeError, NotImplementedError): summary = None # XXX need detailed help here, too help_output = "" if usage is not None: help_output += "%s %s" % (canonical_name, usage) if summary is not None: help_output += "\n\n%s" % summary if usage is None and summary is None: help_output = _("No help available for %s") % canonical_name command_names = command.getNames() if len(command_names) > 1: if len(command_names) > 2: help_output += _("\n\naliases: ") else: help_output += _("\n\nalias: ") help_output += ', '.join(command.getNames()[1:]) return help_output def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ if extcmds[0] in base.yum_cli_commands: command = base.yum_cli_commands[extcmds[0]] base.verbose_logger.info(self._makeOutput(command)) return 0, [] def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ return False class ReInstallCommand(YumCommand): """A class containing methods needed by the cli to execute the reinstall command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['reinstall'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "PACKAGE..." def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run. These include that the program is being run by the root user, that there are enabled repositories with gpg keys, and that this command is called with appropriate arguments. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkRootUID(base) checkGPGKey(base) checkPackageArg(base, basecmd, extcmds) checkEnabledRepo(base, extcmds) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ self.doneCommand(base, _("Setting up Reinstall Process")) return base.reinstallPkgs(extcmds) def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("reinstall a package") def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ return False class DowngradeCommand(YumCommand): """A class containing methods needed by the cli to execute the downgrade command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['downgrade'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "PACKAGE..." def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run. These include that the program is being run by the root user, that there are enabled repositories with gpg keys, and that this command is called with appropriate arguments. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkRootUID(base) checkGPGKey(base) checkPackageArg(base, basecmd, extcmds) checkEnabledRepo(base, extcmds) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ self.doneCommand(base, _("Setting up Downgrade Process")) return base.downgradePkgs(extcmds) def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("downgrade a package") def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ return False class VersionCommand(YumCommand): """A class containing methods needed by the cli to execute the version command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['version'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "[all|installed|available]" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Display a version for the machine and/or available repos.") def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ vcmd = 'installed' if extcmds: vcmd = extcmds[0] if vcmd in ('grouplist', 'groupinfo', 'nogroups', 'nogroups-installed', 'nogroups-available', 'nogroups-all', 'installed', 'all', 'group-installed', 'group-all', 'available', 'all', 'group-available', 'group-all'): extcmds = extcmds[1:] else: vcmd = 'installed' def _append_repos(cols, repo_data): for repoid in sorted(repo_data): cur = repo_data[repoid] ncols = [] last_rev = None for rev in sorted(cur): if rev is None: continue last_rev = cur[rev] ncols.append((" %s/%s" % (repoid, rev), str(cur[rev]))) if None in cur and (not last_rev or cur[None] != last_rev): cols.append((" %s" % repoid, str(cur[None]))) cols.extend(ncols) verbose = base.verbose_logger.isEnabledFor(logginglevels.DEBUG_3) groups = {} if vcmd in ('nogroups', 'nogroups-installed', 'nogroups-available', 'nogroups-all'): gconf = [] if vcmd == 'nogroups': vcmd = 'installed' else: vcmd = vcmd[len('nogroups-'):] else: gconf = yum.config.readVersionGroupsConfig() for group in gconf: groups[group] = set(gconf[group].pkglist) if gconf[group].run_with_packages: groups[group].update(base.run_with_package_names) if vcmd == 'grouplist': print _(" Yum version groups:") for group in sorted(groups): print " ", group return 0, ['version grouplist'] if vcmd == 'groupinfo': for group in groups: if group not in extcmds: continue print _(" Group :"), group print _(" Packages:") if not verbose: for pkgname in sorted(groups[group]): print " ", pkgname else: data = {'envra' : {}, 'rid' : {}} pkg_names = groups[group] pkg_names2pkgs = base._group_names2aipkgs(pkg_names) base._calcDataPkgColumns(data, pkg_names, pkg_names2pkgs) data = [data['envra'], data['rid']] columns = base.calcColumns(data) columns = (-columns[0], -columns[1]) base._displayPkgsFromNames(pkg_names, True, pkg_names2pkgs, columns=columns) return 0, ['version groupinfo'] # Have a way to manually specify a dynamic group of packages, whee. if not vcmd.startswith("group-") and extcmds: for dgrp in extcmds: if '/' not in dgrp: # It's a package name, add it to the cmd line group... if '<cmd line>' not in groups: groups['<cmd line>'] = set() groups['<cmd line>'].add(dgrp) else: # It's a file containing a list of packages... if not os.path.exists(dgrp): base.logger.warn(_(" File doesn't exist: %s"), dgrp) else: pkg_names = open(dgrp).readlines() pkg_names = set(n.strip() for n in pkg_names) dgrp = os.path.basename(dgrp) if dgrp in groups: for num in range(1, 100): ndgrp = dgrp + str(num) if ndgrp in groups: continue dgrp = ndgrp break groups[dgrp] = pkg_names rel = base.conf.yumvar['releasever'] ba = base.conf.yumvar['basearch'] cols = [] if vcmd in ('installed', 'all', 'group-installed', 'group-all'): if True: # Try, YumBase... data = base.rpmdb.simpleVersion(not verbose, groups=groups) lastdbv = base.history.last() if lastdbv is not None: lastdbv = lastdbv.end_rpmdbversion if lastdbv is not None and data[0] != lastdbv: base._rpmdb_warn_checks(warn=lastdbv is not None) if vcmd not in ('group-installed', 'group-all'): cols.append(("%s %s/%s" % (_("Installed:"), rel, ba), str(data[0]))) _append_repos(cols, data[1]) if groups: for grp in sorted(data[2]): if (vcmd.startswith("group-") and extcmds and grp not in extcmds): continue cols.append(("%s %s" % (_("Group-Installed:"), grp), str(data[2][grp]))) _append_repos(cols, data[3][grp]) if vcmd in ('available', 'all', 'group-available', 'group-all'): if True: # Try, YumBase... data = base.pkgSack.simpleVersion(not verbose, groups=groups) if vcmd not in ('group-available', 'group-all'): cols.append(("%s %s/%s" % (_("Available:"), rel, ba), str(data[0]))) if verbose: _append_repos(cols, data[1]) if groups: for grp in sorted(data[2]): if (vcmd.startswith("group-") and extcmds and grp not in extcmds): continue cols.append(("%s %s" % (_("Group-Available:"), grp), str(data[2][grp]))) if verbose: _append_repos(cols, data[3][grp]) data = {'rid' : {}, 'ver' : {}} for (rid, ver) in cols: for (d, v) in (('rid', len(rid)), ('ver', len(ver))): data[d].setdefault(v, 0) data[d][v] += 1 data = [data['rid'], data['ver']] columns = base.calcColumns(data) columns = (-columns[0], columns[1]) for line in cols: print base.fmtColumns(zip(line, columns)) return 0, ['version'] def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ vcmd = 'installed' if extcmds: vcmd = extcmds[0] verbose = base.verbose_logger.isEnabledFor(logginglevels.DEBUG_3) if vcmd == 'groupinfo' and verbose: return True return vcmd in ('available', 'all', 'group-available', 'group-all') def cacheRequirement(self, base, basecmd, extcmds): """Return the cache requirements for the remote repos. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: Type of requirement: read-only:past, read-only:present, read-only:future, write """ return 'read-only:present' class HistoryCommand(YumCommand): """A class containing methods needed by the cli to execute the history command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['history'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "[info|list|packages-list|summary|addon-info|redo|undo|rollback|new]" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Display, or use, the transaction history") def _hcmd_redo(self, base, extcmds): kwargs = {'force_reinstall' : False, 'force_changed_removal' : False, } kwargs_map = {'reinstall' : 'force_reinstall', 'force-reinstall' : 'force_reinstall', 'remove' : 'force_changed_removal', 'force-remove' : 'force_changed_removal', } while len(extcmds) > 1: done = False for arg in extcmds[1].replace(' ', ',').split(','): if arg not in kwargs_map: continue done = True key = kwargs_map[extcmds[1]] kwargs[key] = not kwargs[key] if not done: break extcmds = [extcmds[0]] + extcmds[2:] old = base._history_get_transaction(extcmds) if old is None: return 1, ['Failed history redo'] tm = time.ctime(old.beg_timestamp) print "Repeating transaction %u, from %s" % (old.tid, tm) base.historyInfoCmdPkgsAltered(old) if base.history_redo(old, **kwargs): return 2, ["Repeating transaction %u" % (old.tid,)] def _hcmd_undo(self, base, extcmds): old = base._history_get_transaction(extcmds) if old is None: return 1, ['Failed history undo'] tm = time.ctime(old.beg_timestamp) print "Undoing transaction %u, from %s" % (old.tid, tm) base.historyInfoCmdPkgsAltered(old) if base.history_undo(old): return 2, ["Undoing transaction %u" % (old.tid,)] def _hcmd_rollback(self, base, extcmds): force = False if len(extcmds) > 1 and extcmds[1] == 'force': force = True extcmds = extcmds[:] extcmds.pop(0) old = base._history_get_transaction(extcmds) if old is None: return 1, ['Failed history rollback, no transaction'] last = base.history.last() if last is None: return 1, ['Failed history rollback, no last?'] if old.tid == last.tid: return 0, ['Rollback to current, nothing to do'] mobj = None for tid in base.history.old(range(old.tid + 1, last.tid + 1)): if not force and (tid.altered_lt_rpmdb or tid.altered_gt_rpmdb): if tid.altered_lt_rpmdb: msg = "Transaction history is incomplete, before %u." else: msg = "Transaction history is incomplete, after %u." print msg % tid.tid print " You can use 'history rollback force', to try anyway." return 1, ['Failed history rollback, incomplete'] if mobj is None: mobj = yum.history.YumMergedHistoryTransaction(tid) else: mobj.merge(tid) tm = time.ctime(old.beg_timestamp) print "Rollback to transaction %u, from %s" % (old.tid, tm) print base.fmtKeyValFill(" Undoing the following transactions: ", ", ".join((str(x) for x in mobj.tid))) base.historyInfoCmdPkgsAltered(mobj) if base.history_undo(mobj): return 2, ["Rollback to transaction %u" % (old.tid,)] def _hcmd_new(self, base, extcmds): base.history._create_db_file() def _hcmd_stats(self, base, extcmds): print "File :", base.history._db_file num = os.stat(base.history._db_file).st_size print "Size :", locale.format("%d", num, True) trans_N = base.history.last() if trans_N is None: print _("Transactions:"), 0 return counts = base.history._pkg_stats() trans_1 = base.history.old("1")[0] print _("Transactions:"), trans_N.tid print _("Begin time :"), time.ctime(trans_1.beg_timestamp) print _("End time :"), time.ctime(trans_N.end_timestamp) print _("Counts :") print _(" NEVRAC :"), locale.format("%6d", counts['nevrac'], True) print _(" NEVRA :"), locale.format("%6d", counts['nevra'], True) print _(" NA :"), locale.format("%6d", counts['na'], True) print _(" NEVR :"), locale.format("%6d", counts['nevr'], True) print _(" rpm DB :"), locale.format("%6d", counts['rpmdb'], True) print _(" yum DB :"), locale.format("%6d", counts['yumdb'], True) def _hcmd_sync(self, base, extcmds): extcmds = extcmds[1:] if not extcmds: extcmds = None for ipkg in sorted(base.rpmdb.returnPackages(patterns=extcmds)): if base.history.pkg2pid(ipkg, create=False) is None: continue print "Syncing rpm/yum DB data for:", ipkg, "...", if base.history.sync_alldb(ipkg): print "Done." else: print "FAILED." def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run. The exact conditions checked will vary depending on the subcommand that is being called. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ cmds = ('list', 'info', 'summary', 'repeat', 'redo', 'undo', 'new', 'rollback', 'addon', 'addon-info', 'stats', 'statistics', 'sync', 'synchronize' 'pkg', 'pkgs', 'pkg-list', 'pkgs-list', 'package', 'package-list', 'packages', 'packages-list', 'pkg-info', 'pkgs-info', 'package-info', 'packages-info') if extcmds and extcmds[0] not in cmds: base.logger.critical(_('Invalid history sub-command, use: %s.'), ", ".join(cmds)) raise cli.CliError if extcmds and extcmds[0] in ('repeat', 'redo', 'undo', 'rollback', 'new'): checkRootUID(base) checkGPGKey(base) elif not (base.history._db_file and os.access(base.history._db_file, os.R_OK)): base.logger.critical(_("You don't have access to the history DB.")) raise cli.CliError def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ vcmd = 'list' if extcmds: vcmd = extcmds[0] if False: pass elif vcmd == 'list': ret = base.historyListCmd(extcmds) elif vcmd == 'info': ret = base.historyInfoCmd(extcmds) elif vcmd == 'summary': ret = base.historySummaryCmd(extcmds) elif vcmd in ('addon', 'addon-info'): ret = base.historyAddonInfoCmd(extcmds) elif vcmd in ('pkg', 'pkgs', 'pkg-list', 'pkgs-list', 'package', 'package-list', 'packages', 'packages-list'): ret = base.historyPackageListCmd(extcmds) elif vcmd == 'undo': ret = self._hcmd_undo(base, extcmds) elif vcmd in ('redo', 'repeat'): ret = self._hcmd_redo(base, extcmds) elif vcmd == 'rollback': ret = self._hcmd_rollback(base, extcmds) elif vcmd == 'new': ret = self._hcmd_new(base, extcmds) elif vcmd in ('stats', 'statistics'): ret = self._hcmd_stats(base, extcmds) elif vcmd in ('sync', 'synchronize'): ret = self._hcmd_sync(base, extcmds) elif vcmd in ('pkg-info', 'pkgs-info', 'package-info', 'packages-info'): ret = base.historyPackageInfoCmd(extcmds) if ret is None: return 0, ['history %s' % (vcmd,)] return ret def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ vcmd = 'list' if extcmds: vcmd = extcmds[0] return vcmd in ('repeat', 'redo', 'undo', 'rollback') def cacheRequirement(self, base, basecmd, extcmds): """Return the cache requirements for the remote repos. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: Type of requirement: read-only:past, read-only:present, read-only:future, write """ vcmd = 'list' if extcmds: vcmd = extcmds[0] if vcmd in ('repeat', 'redo', 'undo', 'rollback'): return 'write' return 'read-only:past' class CheckRpmdbCommand(YumCommand): """A class containing methods needed by the cli to execute the check-rpmdb command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['check', 'check-rpmdb'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "[dependencies|duplicates|all]" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Check for problems in the rpmdb") def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ chkcmd = 'all' if extcmds: chkcmd = extcmds def _out(x): print to_unicode(x.__str__()) rc = 0 if base._rpmdb_warn_checks(out=_out, warn=False, chkcmd=chkcmd, header=lambda x: None): rc = 1 return rc, ['%s %s' % (basecmd, chkcmd)] def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ return False def cacheRequirement(self, base, basecmd, extcmds): """Return the cache requirements for the remote repos. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: Type of requirement: read-only:past, read-only:present, read-only:future, write """ return 'read-only:past' class LoadTransactionCommand(YumCommand): """A class containing methods needed by the cli to execute the load-transaction command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['load-transaction', 'load-ts', 'ts-load'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "filename" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("load a saved transaction from filename") def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ def _pkg_avail(l): if not l.startswith('mbr:'): return True # Kind of ... try: pkgtup, current_state = l.split(':')[1].strip().split(' ') current_state = int(current_state.strip()) pkgtup = tuple(pkgtup.strip().split(',')) if current_state == yum.TS_INSTALL: po = base.getInstalledPackageObject(pkgtup) elif current_state == yum.TS_AVAILABLE: po = base.getPackageObject(pkgtup) else: return False # Bad... except: return False # Bad... return True def _pkg_counts(l, counts): if not l.startswith(' ts_state: '): return state = l[len(' ts_state: '):] if state in ('e', 'od', 'ud'): counts['remove'] += 1 elif state in ('i', 'u'): counts['install'] += 1 if not extcmds: extcmds = [tempfile.gettempdir()] load_file = extcmds[0] if os.path.isdir(load_file): self.doneCommand(base, _("showing transaction files from %s") % load_file) yumtxs = sorted(glob.glob("%s/*.yumtx" % load_file)) currpmv = None done = False for yumtx in yumtxs: data = base._load_ts_data(yumtx) if data[0] is not None: continue # Bad file... data = data[1] rpmv = data[0].strip() if currpmv is None: currpmv = str(base.rpmdb.simpleVersion(main_only=True)[0]) if rpmv == currpmv: current = _('y') else: current = ' ' # Not usable is the most common # See load_ts() for data ... try: numrepos = int(data[2].strip()) pkgstart = 3+numrepos numpkgs = int(data[pkgstart].strip()) pkgstart += 1 except: continue counts = {'install' : 0, 'remove' : 0} for l in data[pkgstart:]: l = l.rstrip() _pkg_counts(l, counts) # Check to see if all the packages are available.. bad = ' ' for l in data[pkgstart:]: l = l.rstrip() if _pkg_avail(l): continue bad = '*' break # assert (counts['install'] + counts['remove']) == numpkgs current = '%s%s' % (bad, current) if not done: pkgititle = _("Install") pkgilen = utf8_width(pkgititle) if pkgilen < 6: pkgilen = 6 pkgititle = utf8_width_fill(pkgititle, pkgilen) pkgetitle = _("Remove") pkgelen = utf8_width(pkgetitle) if pkgelen < 6: pkgelen = 6 pkgetitle = utf8_width_fill(pkgetitle, pkgelen) print "?? |", pkgititle, "|", pkgetitle, "|", _("Filename") done = True numipkgs = locale.format("%d", counts['install'], True) numipkgs = "%*s" % (pkgilen, numipkgs) numepkgs = locale.format("%d", counts['remove'], True) numepkgs = "%*s" % (pkgelen, numepkgs) print "%s | %s | %s | %s" % (current, numipkgs, numepkgs, os.path.basename(yumtx)) return 0, [_('Saved transactions from %s; looked at %u files') % (load_file, len(yumtxs))] self.doneCommand(base, _("loading transaction from %s") % load_file) base.load_ts(load_file) return 2, [_('Transaction loaded from %s with %s members') % (load_file, len(base.tsInfo.getMembers()))] def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ if not extcmds or os.path.isdir(extcmds[0]): return False return True def cacheRequirement(self, base, basecmd, extcmds): """Return the cache requirements for the remote repos. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: Type of requirement: read-only:past, read-only:present, read-only:future, write """ if not extcmds or os.path.isdir(extcmds[0]): return 'read-only:past' return 'write' class SwapCommand(YumCommand): """A class containing methods needed by the cli to execute the swap command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['swap'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "[remove|cmd] <pkg|arg(s)> [-- install|cmd] <pkg|arg(s)>" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Simple way to swap packages, instead of using shell") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run. These include that the program is being run by the root user, that there are enabled repositories with gpg keys, and that this command is called with appropriate arguments. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkRootUID(base) checkGPGKey(base) checkSwapPackageArg(base, basecmd, extcmds) checkEnabledRepo(base, extcmds) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ if '--' in extcmds: off = extcmds.index('--') rextcmds = extcmds[:off] iextcmds = extcmds[off+1:] else: rextcmds = extcmds[:1] iextcmds = extcmds[1:] if not (rextcmds and iextcmds): return 1, ['swap'] # impossible if rextcmds[0] not in base.yum_cli_commands: rextcmds = ['remove'] + rextcmds if iextcmds[0] not in base.yum_cli_commands: iextcmds = ['install'] + iextcmds # Very similar to what the shell command does... ocmds = base.cmds oline = base.cmdstring for cmds in (rextcmds, iextcmds): base.cmdstring = " ".join(cmds) base.cmds = cmds # Don't call this atm. as the line has gone through it already, # also makes it hard to do the "is ?extcmds[0] a cmd" check. # base.plugins.run('args', args=base.cmds) # We don't catch exceptions, just pass them up and fail... base.parseCommands() cmdret = base.doCommands() if cmdret[0] != 2: return cmdret[0], ['%s %s' % (basecmd, " ".join(cmds))] base.cmds = ocmds base.cmdstring = oline return 2, ['%s %s' % (basecmd, " ".join(extcmds))] class RepoPkgsCommand(YumCommand): """A class containing methods needed by the cli to execute the repo command. """ def getNames(self): """Return a list containing the names of this command. This command can be called from the command line by using any of these names. :return: a list containing the names of this command """ return ['repo-pkgs', 'repo-packages', 'repository-pkgs', 'repository-packages'] def getUsage(self): """Return a usage string for this command. :return: a usage string for this command """ return "<repoid> <list|info|install|remove|upgrade|reinstall*|remove-or-*> [pkg(s)]" def getSummary(self): """Return a one line summary of this command. :return: a one line summary of this command """ return _("Treat a repo. as a group of packages, so we can install/remove all of them") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run. These include that the program is being run by the root user, that there are enabled repositories with gpg keys, and that this command is called with appropriate arguments. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkRootUID(base) checkGPGKey(base) checkRepoPackageArg(base, basecmd, extcmds) checkEnabledRepo(base, extcmds) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ def _add_repopkg2txmbrs(txmbrs, repoid): for txmbr in txmbrs: txmbr.repopkg = repoid repoid = extcmds[0] cmd = extcmds[1] args = extcmds[2:] noargs = False if not args: noargs = True args = ['*'] num = 0 remap = {'erase' : 'remove', 'erase-or-reinstall' : 'remove-or-reinstall', 'erase-or-sync' : 'remove-or-sync', 'erase-or-distro-sync' : 'remove-or-sync', 'remove-or-distro-sync' : 'remove-or-sync', 'erase-or-distribution-synchronization' : 'remove-or-sync', 'remove-or-distribution-synchronization' : 'remove-or-sync', 'upgrade' : 'update', # Hack, but meh. 'upgrade-to' : 'update-to', # Hack, but meh. 'check-upgrade' : 'check-update', # Hack, but meh. 'check-upgrades' : 'check-update', # Hack, but meh. 'check-updates' : 'check-update', # Hack, but meh. } cmd = remap.get(cmd, cmd) if False: pass elif cmd == 'list': # list/info is easiest... return ListCommand().doCommand(base, cmd, args, repoid=repoid) elif cmd == 'info': return InfoCommand().doCommand(base, cmd, args, repoid=repoid) elif cmd == 'check-update': return CheckUpdateCommand().doCommand(base, cmd, args,repoid=repoid) elif cmd == 'install': # install is simpler version of installPkgs... for arg in args: txmbrs = base.install(pattern=arg, repoid=repoid) _add_repopkg2txmbrs(txmbrs, repoid) num += len(txmbrs) if num: return 2, P_('%d package to install', '%d packages to install', num) elif cmd == 'update': # update is basically the same as install... for arg in args: txmbrs = base.update(pattern=arg, repoid=repoid) _add_repopkg2txmbrs(txmbrs, repoid) num += len(txmbrs) if num: updateinfo.remove_txmbrs(base) return 2, P_('%d package to update', '%d packages to update', num) elif cmd == 'update-to': # update is basically the same as install... for arg in args: txmbrs = base.update(pattern=arg, update_to=True, repoid=repoid) _add_repopkg2txmbrs(txmbrs, repoid) num += len(txmbrs) if num: updateinfo.remove_txmbrs(base) return 2, P_('%d package to update', '%d packages to update', num) elif cmd in ('reinstall-old', 'reinstall-installed'): # We have to choose for reinstall, for "reinstall foo" do we mean: # 1. reinstall the packages that are currently installed from "foo". # 2. reinstall the packages specified to the ones from "foo" # This is for installed.from_repo=foo if noargs: onot_found_a = base._not_found_a.copy() for arg in args: txmbrs = base.reinstall(pattern=arg, repoid=repoid, repoid_install=repoid) _add_repopkg2txmbrs(txmbrs, repoid) num += len(txmbrs) if noargs: base._not_found_a = onot_found_a if num: return 2, P_('%d package to reinstall', '%d packages to reinstall', num) elif cmd in ('reinstall-new', 'reinstall-available', 'move-to'): # This is for move-to the packages from this repo. if noargs: onot_found_a = base._not_found_a.copy() for arg in args: txmbrs = base.reinstall(pattern=arg, repoid_install=repoid) _add_repopkg2txmbrs(txmbrs, repoid) num += len(txmbrs) if noargs: base._not_found_a = onot_found_a if num: return 2, P_('%d package to move to', '%d packages to move to', num) elif cmd == 'reinstall': # This means "guess", so doing the old version unless it produces # nothing, in which case try switching. if noargs: onot_found_a = base._not_found_a.copy() for arg in args: try: txmbrs = base.reinstall(pattern=arg, repoid=repoid,repoid_install=repoid) except yum.Errors.ReinstallRemoveError: continue _add_repopkg2txmbrs(txmbrs, repoid) num += len(txmbrs) if noargs: base._not_found_a = onot_found_a.copy() if num: return 2, P_('%d package to reinstall', '%d packages to reinstall', num) for arg in args: txmbrs = base.reinstall(pattern=arg, repoid_install=repoid) _add_repopkg2txmbrs(txmbrs, repoid) num += len(txmbrs) if noargs: base._not_found_a = onot_found_a if num: return 2, P_('%d package to move to', '%d packages to move to', num) elif cmd == 'remove': # Also mostly the same... for arg in args: txmbrs = base.remove(pattern=arg, repoid=repoid) _add_repopkg2txmbrs(txmbrs, repoid) num += len(txmbrs) if num: return 2, P_('%d package to remove', '%d packages to remove', num) elif cmd == 'remove-or-reinstall': # More complicated... for arg in args: txmbrs = base.remove(pattern=arg, repoid=repoid) # Add an install() if it's in another repo. for txmbr in txmbrs[:]: pkgs = base.pkgSack.searchPkgTuple(txmbr.pkgtup) for pkg in sorted(pkgs): if pkg.repoid == repoid: continue txmbrs += base.install(po=pkg) break _add_repopkg2txmbrs(txmbrs, repoid) num += len(txmbrs) if num: return 2, P_('%d package to remove/reinstall', '%d packages to remove/reinstall', num) elif cmd == 'remove-or-sync': # Even more complicated... for arg in args: txmbrs = base.remove(pattern=arg, repoid=repoid) # Add an install/upgrade/downgrade if a version is in another # repo. for txmbr in txmbrs[:]: pkgs = base.pkgSack.searchNames([txmbr.name]) apkgs = None for pkg in sorted(pkgs): if pkg.repoid == repoid: # Backwards filter_pkgs_repoid continue if apkgs and pkg.verEQ(apkgs[0]): apkgs.append(pkg) else: apkgs = [pkg] if apkgs: for pkg in apkgs: if pkg.arch != txmbr.arch: continue apkgs = [pkg] break if len(apkgs) != 1: apkgs = base.bestPackagesFromList(apkgs) for toinst in apkgs: n,a,e,v,r = toinst.pkgtup if toinst.verEQ(txmbr.po): txmbrs += base.install(po=toinst) elif toinst.verGT(txmbr.po): txmbrs += base.update(po=toinst) else: base.tsInfo.remove(txmbr.pkgtup) txmbrs.remove(txmbr) txmbrs += base.downgrade(po=toinst) _add_repopkg2txmbrs(txmbrs, repoid) num += len(txmbrs) if num: return 2, P_('%d package to remove/sync', '%d packages to remove/sync', num) else: return 1, [_('Not a valid sub-command of %s') % basecmd] return 0, [_('Nothing to do')] def needTs(self, base, basecmd, extcmds): """Return whether a transaction set must be set up before this command can run. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: True if a transaction set is needed, False otherwise """ cmd = 'install' if len(extcmds) > 1: cmd = extcmds[1] if cmd in ('info', 'list'): return InfoCommand().needTs(base, cmd, extcmds[2:]) return True def cacheRequirement(self, base, basecmd, extcmds): """Return the cache requirements for the remote repos. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: a list of arguments passed to *basecmd* :return: Type of requirement: read-only:past, read-only:present, read-only:future, write """ cmd = 'install' if len(extcmds) > 1: cmd = extcmds[1] if cmd in ('info', 'list'): return InfoCommand().cacheRequirement(base, cmd, extcmds[2:]) if cmd in ('check-update', 'check-upgrade', 'check-updates', 'check-upgrades'): return CheckUpdateCommand().cacheRequirement(base, cmd, extcmds[2:]) return 'write' # Using this a lot, so make it easier... _upi = updateinfo class UpdateinfoCommand(YumCommand): # Old command names... direct_cmds = {'list-updateinfo' : 'list', 'list-security' : 'list', 'list-sec' : 'list', 'info-updateinfo' : 'info', 'info-security' : 'info', 'info-sec' : 'info', 'summary-updateinfo' : 'summary'} # Note that this code (instead of using inheritance and multiple # cmd classes) means that "yum help" only displays the updateinfo command. # Which is what we want, because the other commands are just backwards # compatible gunk we don't want the user using). def getNames(self): return ['updateinfo'] + sorted(self.direct_cmds.keys()) def getUsage(self): return "[info|list|...] [security|...] [installed|available|all] [pkgs|id]" def getSummary(self): return "Acts on repository update information" def doCheck(self, base, basecmd, extcmds): pass def list_show_pkgs(self, base, md_info, list_type, show_type, iname2tup, data, msg): n_maxsize = 0 r_maxsize = 0 t_maxsize = 0 for (notice, pkgtup, pkg) in data: n_maxsize = max(len(notice['update_id']), n_maxsize) tn = notice['type'] if tn == 'security' and notice['severity']: tn = notice['severity'] + '/Sec.' t_maxsize = max(len(tn), t_maxsize) if show_type: for ref in _upi._ysp_safe_refs(notice['references']): if ref['type'] != show_type: continue r_maxsize = max(len(str(ref['id'])), r_maxsize) for (notice, pkgtup, pkg) in data: mark = '' if list_type == 'all': mark = ' ' if pkgtup[0] in iname2tup and _upi._rpm_tup_vercmp(iname2tup[pkgtup[0]], pkgtup) >= 0: mark = 'i ' tn = notice['type'] if tn == 'security' and notice['severity']: tn = notice['severity'] + '/Sec.' if show_type and _upi._ysp_has_info_md(show_type, notice): for ref in _upi._ysp_safe_refs(notice['references']): if ref['type'] != show_type: continue msg("%s %-*s %-*s %s" % (mark, r_maxsize, str(ref['id']), t_maxsize, tn, pkg)) elif hasattr(pkg, 'name'): print base.fmtKeyValFill("%s: " % pkg.name, base._enc(pkg.summary)) else: msg("%s%-*s %-*s %s" % (mark, n_maxsize, notice['update_id'], t_maxsize, tn, pkg)) def info_show_pkgs(self, base, md_info, list_type, show_type, iname2tup, data, msg): show_pkg_info_done = {} for (notice, pkgtup, pkg) in data: if notice['update_id'] in show_pkg_info_done: continue show_pkg_info_done[notice['update_id']] = notice if hasattr(notice, 'text'): debug_log_lvl = yum.logginglevels.DEBUG_3 vlog = base.verbose_logger if vlog.isEnabledFor(debug_log_lvl): obj = notice.text(skip_data=[]) else: obj = notice.text() else: # Python-2.4.* doesn't understand str(x) returning unicode obj = notice.__str__() if list_type == 'all': if pkgtup[0] in iname2tup and _upi._rpm_tup_vercmp(iname2tup[pkgtup[0]], pkgtup) >= 0: obj = obj + "\n Installed : true" else: obj = obj + "\n Installed : false" msg(obj) def summary_show_pkgs(self, base, md_info, list_type, show_type, iname2tup, data, msg): def _msg(x): base.verbose_logger.info("%s", x) counts = {} sev_counts = {} show_pkg_info_done = {} for (notice, pkgtup, pkg) in data: if notice['update_id'] in show_pkg_info_done: continue show_pkg_info_done[notice['update_id']] = notice counts[notice['type']] = counts.get(notice['type'], 0) + 1 if notice['type'] == 'security': sev = notice['severity'] if sev is None: sev = '' sev_counts[sev] = sev_counts.get(sev, 0) + 1 maxsize = 0 for T in ('newpackage', 'security', 'bugfix', 'enhancement'): if T not in counts: continue size = len(str(counts[T])) if maxsize < size: maxsize = size if not maxsize: if base.conf.autocheck_running_kernel: _upi._check_running_kernel(base, md_info, _msg) return outT = {'newpackage' : 'New Package', 'security' : 'Security', 'bugfix' : 'Bugfix', 'enhancement' : 'Enhancement'} print "Updates Information Summary:", list_type for T in ('newpackage', 'security', 'bugfix', 'enhancement'): if T not in counts: continue n = outT[T] if T == 'security' and len(sev_counts) == 1: sn = sev_counts.keys()[0] if sn != '': n = sn + " " + n print " %*u %s notice(s)" % (maxsize, counts[T], n) if T == 'security' and len(sev_counts) != 1: def _sev_sort_key(key): # We want these in order, from "highest" to "lowest". # Anything unknown is "higher". meh. return {'Critical' : "zz1", 'Important': "zz2", 'Moderate' : "zz3", 'Low' : "zz4", }.get(key, key) for sn in sorted(sev_counts, key=_sev_sort_key): args = (maxsize, sev_counts[sn],sn or '?', outT['security']) print " %*u %s %s notice(s)" % args if base.conf.autocheck_running_kernel: _upi._check_running_kernel(base, md_info, _msg) self.show_pkg_info_done = {} def _get_new_pkgs(self, md_info): for notice in md_info.notices: if notice['type'] != "newpackage": continue for upkg in notice['pkglist']: for pkg in upkg['packages']: pkgtup = (pkg['name'], pkg['arch'], pkg['epoch'] or '0', pkg['version'], pkg['release']) yield (notice, pkgtup) _cmd2filt = {"bugzillas" : "bugzilla", "bugzilla" : "bugzilla", "bzs" : "bugzilla", "bz" : "bugzilla", "sec" : "security", "cves" : "cve", "cve" : "cve", "newpackages" : "newpackage", "new-packages" : "newpackage", "newpackage" : "newpackage", "new-package" : "newpackage", "new" : "newpackage"} for filt_type in _upi._update_info_types_: _cmd2filt[filt_type] = filt_type def doCommand(self, base, basecmd, extcmds): if basecmd in self.direct_cmds: subcommand = self.direct_cmds[basecmd] elif extcmds and extcmds[0] in ('list', 'info', 'summary', 'remove-pkgs-ts', 'exclude-updates', 'exclude-all', 'check-running-kernel'): subcommand = extcmds[0] extcmds = extcmds[1:] elif extcmds and extcmds[0] in self._cmd2filt: subcommand = 'list' elif extcmds: subcommand = 'info' else: subcommand = 'summary' if subcommand == 'list': return self.doCommand_li(base, 'updateinfo list', extcmds, self.list_show_pkgs) if subcommand == 'info': return self.doCommand_li(base, 'updateinfo info', extcmds, self.info_show_pkgs) if subcommand == 'summary': return self.doCommand_li(base, 'updateinfo summary', extcmds, self.summary_show_pkgs) if subcommand == 'remove-pkgs-ts': filters = None if extcmds: filters = updateinfo._args2filters(extcmds) updateinfo.remove_txmbrs(base, filters) return 0, [basecmd + ' ' + subcommand + ' done'] if subcommand == 'exclude-all': filters = None if extcmds: filters = updateinfo._args2filters(extcmds) updateinfo.exclude_all(base, filters) return 0, [basecmd + ' ' + subcommand + ' done'] if subcommand == 'exclude-updates': filters = None if extcmds: filters = updateinfo._args2filters(extcmds) updateinfo.exclude_updates(base, filters) return 0, [basecmd + ' ' + subcommand + ' done'] if subcommand == 'check-running-kernel': def _msg(x): base.verbose_logger.info("%s", x) updateinfo._check_running_kernel(base, base.upinfo, _msg) return 0, [basecmd + ' ' + subcommand + ' done'] def doCommand_li_new(self, base, list_type, extcmds, md_info, msg, show_pkgs, iname2tup): done_pkgs = set() data = [] for (notice, pkgtup) in sorted(self._get_new_pkgs(md_info), key=lambda x: x[1][0]): if extcmds and not _upi._match_sec_cmd(extcmds, pkgtup[0], notice): continue n = pkgtup[0] if n in done_pkgs: continue ipkgs = list(reversed(sorted(base.rpmdb.searchNames([n])))) if list_type in ('installed', 'updates') and not ipkgs: done_pkgs.add(n) continue if list_type == 'available' and ipkgs: done_pkgs.add(n) continue pkgs = base.pkgSack.searchPkgTuple(pkgtup) if not pkgs: continue if list_type == "updates" and pkgs[0].verLE(ipkgs[0]): done_pkgs.add(n) continue done_pkgs.add(n) data.append((notice, pkgtup, pkgs[0])) show_pkgs(base, md_info, list_type, None, iname2tup, data, msg) def _parse_extcmds(self, extcmds): filt_type = None show_type = None if len(extcmds) >= 1: filt_type = None if extcmds[0] in self._cmd2filt: filt_type = self._cmd2filt[extcmds.pop(0)] show_type = filt_type if filt_type and filt_type in _upi._update_info_types_: show_type = None return extcmds, show_type, filt_type def doCommand_li(self, base, basecmd, extcmds, show_pkgs): md_info = base.upinfo def msg(x): # Don't use: logger.log(logginglevels.INFO_2, x) # or -q deletes everything. print x extcmds, show_type, filt_type = self._parse_extcmds(extcmds) list_type = "available" list_type = "updates" if extcmds and extcmds[0] in ("updates","available","installed", "all"): list_type = extcmds.pop(0) if filt_type is None: extcmds, show_type, filt_type = self._parse_extcmds(extcmds) opts = _upi._ysp_gen_opts(base.updateinfo_filters, extcmds) used_map = _upi._ysp_gen_used_map(base.updateinfo_filters) iname2tup = {} if False: pass elif list_type == 'installed': name2tup = _upi._get_name2allpkgtup(base) iname2tup = _upi._get_name2instpkgtup(base) elif list_type == 'updates': name2tup = _upi._get_name2oldpkgtup(base) elif list_type in ('available', 'all'): name2tup = _upi._get_name2aallpkgtup(base) iname2tup = _upi._get_name2instpkgtup(base) if filt_type == "newpackage": self.doCommand_li_new(base, list_type, extcmds, md_info, msg, show_pkgs, iname2tup) return 0, [basecmd + ' new done'] def _show_pkgtup(pkgtup): name = pkgtup[0] notices = reversed(md_info.get_applicable_notices(pkgtup)) for (pkgtup, notice) in notices: if filt_type and not _upi._ysp_has_info_md(filt_type, notice): continue if list_type == 'installed': # Remove any that are newer than what we have installed if _upi._rpm_tup_vercmp(iname2tup[name], pkgtup) < 0: continue if list_type == 'available': # Remove any that are installed if name in iname2tup and _upi._rpm_tup_vercmp(iname2tup[name], pkgtup) >= 0: continue if _upi._ysp_should_filter_pkg(opts, name, notice, used_map): yield (pkgtup, notice) data = [] for pkgname in sorted(name2tup): for (pkgtup, notice) in _show_pkgtup(name2tup[pkgname]): d = {} (d['n'], d['a'], d['e'], d['v'], d['r']) = pkgtup if d['e'] == '0': d['epoch'] = '' else: d['epoch'] = "%s:" % d['e'] data.append((notice, pkgtup, "%(n)s-%(epoch)s%(v)s-%(r)s.%(a)s" % d)) show_pkgs(base, md_info, list_type, show_type, iname2tup, data, msg) _upi._ysp_chk_used_map(used_map, msg) return 0, [basecmd + ' done'] class UpdateMinimalCommand(YumCommand): def getNames(self): return ['update-minimal', 'upgrade-minimal'] def getUsage(self): return "[PACKAGE-wildcard]" def getSummary(self): return _("Works like upgrade, but goes to the 'newest' package match which fixes a problem that affects your system") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run. These include that the program is being run by the root user, that there are enabled repositories with gpg keys, and that this command is called with appropriate arguments. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkRootUID(base) checkGPGKey(base) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ num = len(base.tsInfo) _upi.update_minimal(base, extcmds) num = len(base.tsInfo) - num if num > 0: msg = '%d packages marked for minimal Update' % num return 2, [msg] else: return 0, ['No Packages marked for minimal Update'] class FSSnapshotCommand(YumCommand): def getNames(self): return ['fssnapshot', 'fssnap'] def getUsage(self): return "[]" def getSummary(self): return _("Creates filesystem snapshots, or lists/deletes current snapshots.") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run. These include that the program is being run by the root user, that there are enabled repositories with gpg keys, and that this command is called with appropriate arguments. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ checkRootUID(base) @staticmethod def _li_snaps(base, snaps): snaps = sorted(snaps, key=lambda x: x['dev']) max_dev = utf8_width(_('Snapshot')) max_ori = utf8_width(_('Origin')) for data in snaps: max_dev = max(max_dev, len(data['dev'])) max_ori = max(max_ori, len(data['origin'])) done = False for data in snaps: if not done: print ("%s %s %s %s %s %s" % (utf8_width_fill(_('Snapshot'), max_dev), utf8_width_fill(_('Size'), 6, left=False), utf8_width_fill(_('Used'), 6, left=False), utf8_width_fill(_('Free'), 6, left=False), utf8_width_fill(_('Origin'), max_ori), _('Tags'))) done = True print ("%*s %6s %5.1f%% %6s %*s %s" % (max_dev, data['dev'], base.format_number(data['size']), data['used'], base.format_number(data['free']), max_ori, data['origin'], ",".join(data['tags']))) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ if extcmds and extcmds[0] in ('list', 'delete', 'create', 'summary', 'have-space', 'has-space'): subcommand = extcmds[0] extcmds = extcmds[1:] else: subcommand = 'summary' if not base.fssnap.available: msg = _("Snapshot support not available, please check your lvm installation.") if not base.rpmdb.searchNames(['lvm2']): msg += " " + _("No lvm2 package installed.") if not base.rpmdb.searchNames(['lvm2-python-libs']): msg += " " + _("No lvm2-python-libs package installed.") print msg return 1, [basecmd + ' ' + subcommand + ' done'] if subcommand == 'list': try: snaps = base.fssnap.old_snapshots() except LibLVMError as e: return 1, [_("Failed to list snapshots: ") + lvmerr2str(e)] print _("List of %u snapshosts:") % len(snaps) self._li_snaps(base, snaps) if subcommand == 'delete': msg = _("Failed to delete snapshots: ") try: snaps = base.fssnap.old_snapshots() except LibLVMError as e: return 1, [msg + lvmerr2str(e)] devs = [x['dev'] for x in snaps] snaps = set() for dev in devs: if dev in snaps: continue for extcmd in extcmds: if dev == extcmd or fnmatch.fnmatch(dev, extcmd): snaps.add(dev) break try: snaps = base.fssnap.del_snapshots(devices=snaps) except LibLVMError as e: return 1, [msg + lvmerr2str(e)] print _("Deleted %u snapshosts:") % len(snaps) self._li_snaps(base, snaps) if subcommand in ('have-space', 'has-space'): pc = base.conf.fssnap_percentage try: has_space = base.fssnap.has_space(pc) except LibLVMError as e: return 1, [_("Could not determine free space on logical volumes: ") + lvmerr2str(e)] if has_space: print _("Space available to take a snapshot.") else: print _("Not enough space available on logical volumes to take a snapshot.") if subcommand == 'create': tags = {'*': ['reason=manual']} pc = base.conf.fssnap_percentage msg = _("Failed to create snapshots") try: snaps = base.fssnap.snapshot(pc, tags=tags) except LibLVMError as e: msg += ": " + lvmerr2str(e) snaps = [] if not snaps: print msg for (odev, ndev) in snaps: print _("Created snapshot from %s, results is: %s") %(odev,ndev) if subcommand == 'summary': try: snaps = base.fssnap.old_snapshots() except LibLVMError as e: return 1, [_("Failed to list snapshots: ") + lvmerr2str(e)] if not snaps: print _("No snapshots, LVM version:"), base.fssnap.version return 0, [basecmd + ' ' + subcommand + ' done'] used = 0 dev_oris = set() for snap in snaps: used += snap['used'] dev_oris.add(snap['origin_dev']) msg = _("Have %u snapshots, using %s space, from %u origins.") print msg % (len(snaps), base.format_number(used), len(dev_oris)) return 0, [basecmd + ' ' + subcommand + ' done'] class FSCommand(YumCommand): def getNames(self): return ['fs'] def getUsage(self): return "[]" def getSummary(self): return _("Acts on the filesystem data of the host, mainly for removing docs/lanuages for minimal hosts.") def doCheck(self, base, basecmd, extcmds): """Verify that conditions are met so that this command can run. These include that the program is being run by the root user, that there are enabled repositories with gpg keys, and that this command is called with appropriate arguments. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* """ if extcmds and extcmds[0] in ('du', 'status', 'diff'): # Anyone can go for it... return if len(extcmds) == 1 and extcmds[0] in ('filters', 'filter'): # Can look, but not touch. return checkRootUID(base) def _fs_pkg_walk(self, pkgs, prefix, modified=False, verbose=False): pfr = {'norm' : {}, 'mod' : {}, 'ghost' : {}, 'miss' : {}, 'not' : {} } def quick_match(pkgs): for pkg in pkgs: for fname in pkg.filelist + pkg.dirlist: if not fname.startswith(prefix): continue pfr['norm'][fname] = pkg for fname in pkg.ghostlist: if not fname.startswith(prefix): continue pfr['ghost'][fname] = pkg return pfr def _quick_match_iter(pkgs): # Walking the fi information is much slower than filelist/dirlist for pkg in pkgs: found = False for fname in pkg.dirlist: if fname.startswith(prefix): yield pkg found = True break if found: continue for fname in pkg.filelist: if fname.startswith(prefix): yield pkg found = True break if found: continue for fname in pkg.ghostlist: if fname.startswith(prefix): yield pkg break def verify_match(pkgs): _pfs = [] def scoop_pfs(pfs): _pfs.append(pfs) if not modified: return [] return pfs if prefix != '/': pkgs = _quick_match_iter(pkgs) for pkg in pkgs: _pfs = [] probs = pkg.verify(patterns=[prefix+'*'], fake_problems=False, callback=scoop_pfs, failfast=True) for pf in _pfs[0]: if pf.filename in probs: pfr['mod'][pf.filename] = pkg elif pf.rpmfile_state == 'not installed': pfr['not'][pf.filename] = pkg elif 'ghost' in pf.rpmfile_types: pfr['ghost'][pf.filename] = pkg elif 'missing ok' in pf.rpmfile_types: pfr['miss'][pf.filename] = pkg else: pfr['norm'][pf.filename] = pkg return pfr # return quick_match(pkgs) return verify_match(pkgs) def _fs_du(self, base, extcmds): def _dir_prefixes(path): while path != '/': path = os.path.dirname(path) yield path def loc_num(x): """ String of a number in the readable "locale" format. """ return locale.format("%d", int(x), True) data = {'pkgs_size' : {}, 'pkgs_not_size' : {}, 'pkgs_ghost_size' : {}, 'pkgs_miss_size' : {}, 'pkgs_mod_size' : {}, 'pres_size' : {}, 'data_size' : {}, 'data_not_size' : {}, 'pkgs_count' : 0, 'pkgs_not_count' : 0, 'pkgs_ghost_count' : 0, 'pkgs_miss_count' : 0, 'pkgs_mod_count' : 0, 'data_count' : 0} # data_not_count == pkgs_not_count def _add_size(d, v, size): if v not in d: d[v] = 0 d[v] += size def deal_with_file(fpath, need_prefix=True): size = os.path.getsize(fpath) if fpath in pfr['norm']: data['pkgs_count'] += size _add_size(data['pkgs_size'], pfr['norm'][fpath], size) elif fpath in pfr['ghost']: data['pkgs_ghost_count'] += size _add_size(data['pkgs_ghost_size'], pfr['ghost'][fpath], size) elif fpath in pfr['not']: data['pkgs_not_count'] += size _add_size(data['pkgs_not_size'], pfr['not'][fpath], size) data['data_not_size'][fpath] = size elif fpath in pfr['miss']: data['pkgs_miss_count'] += size _add_size(data['pkgs_miss_size'], pfr['miss'][fpath], size) elif fpath in pfr['mod']: data['pkgs_mod_count'] += size _add_size(data['pkgs_mod_size'], pfr['mod'][fpath], size) elif need_prefix and False: for fpre_path in _dir_prefixes(fpath): if fpre_path not in pkg_files: continue _add_size(data['pres_size'], pkg_files[fpre_path], size) break data['data_count'] += size data['data_size'][fpath] = size else: data['data_count'] += size data['data_size'][fpath] = size prefix = "." if extcmds: prefix = extcmds[0] extcmds = extcmds[1:] if not os.path.exists(prefix): return 1, [_('No such file or directory: ' + prefix)] max_show_len = 4 if extcmds: try: max_show_len = int(extcmds[0]) except: pass verbose = base.verbose_logger.isEnabledFor(logginglevels.DEBUG_3) pfr = self._fs_pkg_walk(base.rpmdb, prefix, verbose=verbose) base.closeRpmDB() # C-c ftw. num = 0 if os.path.isfile(prefix): num += 1 deal_with_file(prefix) for root, dirs, files in os.walk(prefix): for fname in files: num += 1 fpath = os.path.normpath(root + '/' + fname) if os.path.islink(fpath): continue deal_with_file(fpath, need_prefix=verbose) # output print "Files :", loc_num(num) tot = 0 tot += data['pkgs_count'] tot += data['pkgs_ghost_count'] tot += data['pkgs_not_count'] tot += data['pkgs_miss_count'] tot += data['pkgs_mod_count'] tot += data['data_count'] print "Total size :", base.format_number(tot) if not tot: return num = data['pkgs_count'] if not verbose: num += data['pkgs_ghost_count'] num += data['pkgs_miss_count'] num += data['pkgs_mod_count'] print " Pkgs size :", "%-5s" % base.format_number(num), print "(%3.0f%%)" % ((num * 100.0) / tot) if verbose: for (title, num) in ((_(" Ghost pkgs size :"), data['pkgs_ghost_count']), (_(" Not pkgs size :"), data['pkgs_not_count']), (_(" Miss pkgs size :"), data['pkgs_miss_count']), (_(" Mod. pkgs size :"), data['pkgs_mod_count'])): if not num: continue print title, "%-5s" % base.format_number(num), print "(%3.0f%%)" % ((num * 100.0) / tot) num = data['data_count'] if not verbose: num += data['pkgs_not_count'] print _(" Data size :"), "%-5s" % base.format_number(num), print "(%3.0f%%)" % ((num * 100.0) / tot) if verbose: print '' print _("Pkgs :"), loc_num(len(data['pkgs_size'])) print _("Ghost Pkgs :"), loc_num(len(data['pkgs_ghost_size'])) print _("Not Pkgs :"), loc_num(len(data['pkgs_not_size'])) print _("Miss. Pkgs :"), loc_num(len(data['pkgs_miss_size'])) print _("Mod. Pkgs :"), loc_num(len(data['pkgs_mod_size'])) def _pkgs(p_size, msg): tot = min(max_show_len, len(p_size)) if tot: print '' print msg % tot num = 0 for pkg in sorted(p_size, key=lambda x: p_size[x], reverse=True): num += 1 print _("%*d. %60s %-5s") % (len(str(tot)), num, pkg, base.format_number(p_size[pkg])) if num >= tot: break if verbose: _pkgs(data['pkgs_size'], _('Top %d packages:')) _pkgs(data['pkgs_ghost_size'], _('Top %d ghost packages:')) _pkgs(data['pkgs_not_size'], _('Top %d not. packages:')) _pkgs(data['pkgs_miss_size'], _('Top %d miss packages:')) _pkgs(data['pkgs_mod_size'], _('Top %d mod. packages:')) _pkgs(data['pres_size'], _('Top %d prefix packages:')) else: tmp = {} tmp.update(data['pkgs_size']) for d in data['pkgs_ghost_size']: _add_size(tmp, d, data['pkgs_ghost_size'][d]) for d in data['pkgs_miss_size']: _add_size(tmp, d, data['pkgs_miss_size'][d]) for d in data['pkgs_mod_size']: _add_size(tmp, d, data['pkgs_mod_size'][d]) _pkgs(tmp, _('Top %d packages:')) print '' if verbose: data_size = data['data_size'] else: data_size = {} data_size.update(data['data_size']) data_size.update(data['data_not_size']) tot = min(max_show_len, len(data_size)) if tot: print _('Top %d non-package files:') % tot num = 0 for fname in sorted(data_size, key=lambda x: data_size[x], reverse=True): num += 1 dsznum = data_size[fname] print _("%*d. %60s %-5s") % (len(str(tot)), num, fname, base.format_number(dsznum)) if num >= tot: break def _fs_filters(self, base, extcmds): def _save(confkey): writeRawConfigFile = yum.config._writeRawConfigFile # Always create installroot, so we can change it. if not os.path.exists(base.conf.installroot + '/etc/yum'): os.makedirs(base.conf.installroot + '/etc/yum') fn = base.conf.installroot+'/etc/yum/yum.conf' if not os.path.exists(fn): # Try the old default nfn = base.conf.installroot+'/etc/yum.conf' if os.path.exists(nfn): fn = nfn else: shutil.copy2(base.conf.config_file_path, fn) ybc = base.conf writeRawConfigFile(fn, 'main', ybc.yumvar, ybc.cfg.options, ybc.iteritems, ybc.optionobj, only=[confkey]) if not extcmds: oil = base.conf.override_install_langs if not oil: oil = "rpm: " + rpm.expandMacro("%_install_langs") print _("File system filters:") print _(" Nodocs:"), 'nodocs' in base.conf.tsflags print _(" Languages:"), oil elif extcmds[0] in ('docs', 'nodocs', 'documentation', 'nodocumentation'): c_f = 'nodocs' in base.conf.tsflags n_f = not extcmds[0].startswith('no') if n_f == c_f: if n_f: print _("Already enabled documentation filter.") else: print _("Already disabled documentation filter.") return if n_f: print _("Enabling documentation filter.") else: print _("Disabling documentation filter.") nts = base.conf.tsflags if n_f: nts = nts + ['nodocs'] else: nts = [x for x in nts if x != 'nodocs'] base.conf.tsflags = " ".join(nts) _save('tsflags') elif extcmds[0] in ('langs', 'nolangs', 'lang', 'nolang', 'languages', 'nolanguages', 'language', 'nolanguage'): if extcmds[0].startswith('no') or len(extcmds) < 2 or 'all' in extcmds: val = 'all' else: val = ":".join(extcmds[1:]) if val == base.conf.override_install_langs: if val: print _("Already filtering languages to: %s") % val else: print _("Already disabled language filter.") return if val: print _("Setting language filter to: %s") % val else: print _("Disabling language filter.") base.conf.override_install_langs = val _save('override_install_langs') else: return 1, [_('Not a valid sub-command of fs filter')] def _fs_refilter(self, base, extcmds): c_f = 'nodocs' in base.conf.tsflags # FIXME: C&P from init. oil = base.conf.override_install_langs if not oil: oil = rpm.expandMacro("%_install_langs") if oil == 'all': oil = '' elif oil: oil = ":".join(sorted(oil.split(':'))) found = False num = 0 for pkg in base.rpmdb.returnPackages(patterns=extcmds): if False: pass elif oil != pkg.yumdb_info.get('ts_install_langs', ''): txmbrs = base.reinstall(po=pkg) num += len(txmbrs) elif c_f != ('true' == pkg.yumdb_info.get('tsflag_nodocs')): txmbrs = base.reinstall(po=pkg) num += len(txmbrs) else: found = True if num: return 2,P_('%d package to reinstall','%d packages to reinstall', num) if not found: return 1, [_('No valid packages: %s') % " ".join(extcmds)] def _fs_refilter_cleanup(self, base, extcmds): pkgs = base.rpmdb.returnPackages(patterns=extcmds) verbose = base.verbose_logger.isEnabledFor(logginglevels.DEBUG_3) pfr = self._fs_pkg_walk(pkgs, "/", verbose=verbose, modified=True) base.closeRpmDB() # C-c ftw. for fname in sorted(pfr['not']): print _('Removing:'), fname try: # Ignore everything, unlink_f() doesn't. os.unlink(fname) except OSError, e: if e.errno == errno.EISDIR: try: os.rmdir(fname) except: pass except: pass def _fs_diff(self, base, extcmds): def deal_with_file(fpath): if fpath in pfr['norm']: pass elif fpath in pfr['ghost']: pass elif fpath in pfr['not']: print >>sys.stderr, _('Not installed:'), fpath elif fpath in pfr['miss']: pass elif fpath in pfr['mod']: pkg = apkgs[pfr['mod'][fpath].pkgtup] # Hacky ... but works. sys.stdout.flush() extract_cmd = "cd %s; rpm2cpio %s | cpio --quiet -id .%s" extract_cmd = extract_cmd % (tmpdir, pkg.localPkg(), fpath) os.system(extract_cmd) diff_cmd = "diff -ru %s %s" % (tmpdir + fpath, fpath) print diff_cmd sys.stdout.flush() os.system(diff_cmd) else: print >>sys.stderr, _('Not packaged?:'), fpath if not distutils.spawn.find_executable("diff"): raise yum.Errors.YumBaseError, _("Can't find diff command") # These just shouldn't happen... if not distutils.spawn.find_executable("cpio"): raise yum.Errors.YumBaseError, _("Can't find cpio command") if not distutils.spawn.find_executable("rpm2cpio"): raise yum.Errors.YumBaseError, _("Can't find rpm2cpio command") prefix = "." if extcmds: prefix = extcmds[0] extcmds = extcmds[1:] pkgs = base.rpmdb.returnPackages(patterns=extcmds) verbose = base.verbose_logger.isEnabledFor(logginglevels.DEBUG_3) pfr = self._fs_pkg_walk(pkgs, prefix, verbose=verbose, modified=True) base.closeRpmDB() # C-c ftw. apkgs = {} downloadpkgs = [] for ipkg in set(pfr['mod'].values()): iyi = ipkg.yumdb_info if 'from_repo' in iyi: # Updates-testing etc. if iyi.from_repo in base.repos.repos: repo = base.repos.getRepo(iyi.from_repo) if not repo.isEnabled(): base.repos.enableRepo(repo.id) for apkg in base.pkgSack.searchPkgTuple(ipkg.pkgtup): if ('checksum_type' in iyi and 'checksum_data' in iyi and iyi.checksum_type == apkg.checksum_type and iyi.checksum_data == apkg.pkgId): apkgs[ipkg.pkgtup] = apkg downloadpkgs.append(apkg) break if ipkg.pkgtup not in apkgs: raise yum.Errors.YumBaseError, _("Can't find package: %s") %ipkg if downloadpkgs: tmpdir = tempfile.mkdtemp() problems = base.downloadPkgs(downloadpkgs, callback_total=base.download_callback_total_cb) if len(problems) > 0: errstring = '' errstring += _('Error downloading packages:\n') for key in problems: errors = yum.misc.unique(problems[key]) for error in errors: errstring += ' %s: %s\n' % (key, error) raise yum.Errors.YumBaseError, errstring for root, dirs, files in os.walk(prefix): for fname in files: fpath = os.path.normpath(root + '/' + fname) if os.path.islink(fpath): continue deal_with_file(fpath) if downloadpkgs: shutil.rmtree(tmpdir) def _fs_status(self, base, extcmds): def deal_with_file(fpath): if fpath in pfr['norm']: pass elif fpath in pfr['ghost']: pass elif fpath in pfr['not']: print _('Not installed:'), fpath elif fpath in pfr['miss']: pass elif fpath in pfr['mod']: print _('Modified:'), fpath else: print _('Not packaged?:'), fpath prefix = "." if extcmds: prefix = extcmds[0] extcmds = extcmds[1:] pkgs = base.rpmdb.returnPackages(patterns=extcmds) verbose = base.verbose_logger.isEnabledFor(logginglevels.DEBUG_3) pfr = self._fs_pkg_walk(pkgs, prefix, verbose=verbose, modified=True) base.closeRpmDB() # C-c ftw. for root, dirs, files in os.walk(prefix): for fname in files: fpath = os.path.normpath(root + '/' + fname) if os.path.islink(fpath): continue deal_with_file(fpath) def doCommand(self, base, basecmd, extcmds): """Execute this command. :param base: a :class:`yum.Yumbase` object :param basecmd: the name of the command :param extcmds: the command line arguments passed to *basecmd* :return: (exit_code, [ errors ]) exit_code is:: 0 = we're done, exit 1 = we've errored, exit with error string 2 = we've got work yet to do, onto the next stage """ if extcmds and extcmds[0] in ('filters', 'filter', 'refilter', 'refilter-cleanup', 'du', 'status', 'diff', 'snap'): subcommand = extcmds[0] extcmds = extcmds[1:] else: subcommand = 'filters' if False: pass elif subcommand == 'du': ret = self._fs_du(base, extcmds) elif subcommand in ('filter', 'filters'): ret = self._fs_filters(base, extcmds) elif subcommand == 'refilter': ret = self._fs_refilter(base, extcmds) elif subcommand == 'refilter-cleanup': ret = self._fs_refilter_cleanup(base, extcmds) elif subcommand == 'diff': ret = self._fs_diff(base, extcmds) elif subcommand == 'status': ret = self._fs_status(base, extcmds) elif subcommand == 'snap': ret = FSSnapshotCommand().doCommand(base, 'fs snap', args) else: return 1, [_('Not a valid sub-command of %s') % basecmd] if ret is not None: return ret return 0, [basecmd + ' ' + subcommand + ' done']