| Current Path : /usr/share/yum-cli/ |
Linux gator3171.hostgator.com 4.19.286-203.ELK.el7.x86_64 #1 SMP Wed Jun 14 04:33:55 CDT 2023 x86_64 |
| Current File : //usr/share/yum-cli/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']