#!/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 2005 Duke University
# Written by Seth Vidal
"""
Command line interface yum class and related.
"""
import os
import re
import sys
import time
import random
import logging
import math
from optparse import OptionParser,OptionGroup,SUPPRESS_HELP
import rpm
import ctypes
import glob
from weakref import proxy as weakref
import output
import shell
import yum
import yum.Errors
import yum.logginglevels
import yum.misc
import yum.plugins
from rpmUtils.arch import isMultiLibArch
from yum import _, P_
from yum.rpmtrans import RPMTransaction
import signal
import yumcommands
from yum.i18n import to_unicode, to_utf8, exception2msg
# This is for yum-utils/yumdownloader in RHEL-5, where it isn't importing this
# directly but did do "from cli import *", and we did have this in 3.2.22. I
# just _love_ how python re-exports these by default.
# pylint: disable-msg=W0611
from yum.packages import parsePackages
# pylint: enable-msg=W0611
def sigquit(signum, frame):
"""SIGQUIT handler for the yum cli. This function will print an
error message and exit the program.
:param signum: unused
:param frame: unused
"""
print >> sys.stderr, "Quit signal sent - exiting immediately"
sys.exit(1)
class CliError(yum.Errors.YumBaseError):
"""Command line interface related Exception."""
def __init__(self, args=''):
yum.Errors.YumBaseError.__init__(self)
self.args = args
class YumBaseCli(yum.YumBase, output.YumOutput):
"""This is the base class for yum cli."""
def __init__(self):
# handle sigquit early on
signal.signal(signal.SIGQUIT, sigquit)
yum.YumBase.__init__(self)
output.YumOutput.__init__(self)
logging.basicConfig()
self.logger = logging.getLogger("yum.cli")
self.verbose_logger = logging.getLogger("yum.verbose.cli")
self.yum_cli_commands = {}
self.use_txmbr_in_callback = True
self.registerCommand(yumcommands.InstallCommand())
self.registerCommand(yumcommands.UpdateCommand())
self.registerCommand(yumcommands.InfoCommand())
self.registerCommand(yumcommands.ListCommand())
self.registerCommand(yumcommands.EraseCommand())
self.registerCommand(yumcommands.GroupsCommand())
self.registerCommand(yumcommands.MakeCacheCommand())
self.registerCommand(yumcommands.CleanCommand())
self.registerCommand(yumcommands.ProvidesCommand())
self.registerCommand(yumcommands.CheckUpdateCommand())
self.registerCommand(yumcommands.SearchCommand())
self.registerCommand(yumcommands.UpgradeCommand())
self.registerCommand(yumcommands.LocalInstallCommand())
self.registerCommand(yumcommands.ResolveDepCommand())
self.registerCommand(yumcommands.ShellCommand())
self.registerCommand(yumcommands.DepListCommand())
self.registerCommand(yumcommands.RepoListCommand())
self.registerCommand(yumcommands.HelpCommand())
self.registerCommand(yumcommands.ReInstallCommand())
self.registerCommand(yumcommands.DowngradeCommand())
self.registerCommand(yumcommands.VersionCommand())
self.registerCommand(yumcommands.HistoryCommand())
self.registerCommand(yumcommands.CheckRpmdbCommand())
self.registerCommand(yumcommands.DistroSyncCommand())
self.registerCommand(yumcommands.LoadTransactionCommand())
self.registerCommand(yumcommands.SwapCommand())
self.registerCommand(yumcommands.RepoPkgsCommand())
self.registerCommand(yumcommands.UpdateinfoCommand())
self.registerCommand(yumcommands.UpdateMinimalCommand())
self.registerCommand(yumcommands.FSSnapshotCommand())
self.registerCommand(yumcommands.FSCommand())
def registerCommand(self, command):
"""Register a :class:`yumcommands.YumCommand` so that it can be called by
any of the names returned by its
:func:`yumcommands.YumCommand.getNames` method.
:param command: the :class:`yumcommands.YumCommand` to register
"""
for name in command.getNames():
if name in self.yum_cli_commands:
raise yum.Errors.ConfigError(_('Command "%s" already defined') % name)
self.yum_cli_commands[name] = command
def doRepoSetup(self, thisrepo=None, dosack=1):
"""Grab the repomd.xml for each enabled and set up the basics
of the repository.
:param thisrepo: the repository to set up
:param dosack: whether to get the repo sack
"""
if self._repos and thisrepo is None:
return self._repos
if not thisrepo:
self.verbose_logger.log(yum.logginglevels.INFO_2,
_('Setting up repositories'))
# Call parent class to do the bulk of work
# (this also ensures that reposetup plugin hook is called)
if thisrepo:
yum.YumBase._getRepos(self, thisrepo=thisrepo, doSetup=True)
else:
yum.YumBase._getRepos(self, thisrepo=thisrepo)
if dosack: # so we can make the dirs and grab the repomd.xml but not import the md
self.verbose_logger.log(yum.logginglevels.INFO_2,
_('Reading repository metadata in from local files'))
self._getSacks(thisrepo=thisrepo)
return self._repos
def _makeUsage(self):
"""
Format an attractive usage string for yum, listing subcommand
names and summary usages.
"""
usage = 'yum [options] COMMAND\n\nList of Commands:\n\n'
commands = yum.misc.unique([x for x in self.yum_cli_commands.values()
if not (hasattr(x, 'hidden') and x.hidden)])
commands.sort(key=lambda x: x.getNames()[0])
for command in commands:
# XXX Remove this when getSummary is common in plugins
try:
summary = command.getSummary()
usage += "%-14s %s\n" % (command.getNames()[0], summary)
except (AttributeError, NotImplementedError):
usage += "%s\n" % command.getNames()[0]
return usage
def _parseSetOpts(self, setopts):
"""parse the setopts list handed to us and saves the results as
repo_setopts and main_setopts in the yumbase object"""
repoopts = {}
mainopts = yum.misc.GenericHolder()
mainopts.items = []
bad_setopt_tm = []
bad_setopt_ne = []
for item in setopts:
vals = item.split('=')
if len(vals) > 2:
bad_setopt_tm.append(item)
continue
if len(vals) < 2:
bad_setopt_ne.append(item)
continue
k, v = [i.strip() for i in vals]
period = k.rfind('.')
if period != -1:
repo = k[:period]
k = k[period+1:]
if repo not in repoopts:
repoopts[repo] = yum.misc.GenericHolder()
repoopts[repo].items = []
setattr(repoopts[repo], k, v)
repoopts[repo].items.append(k)
else:
setattr(mainopts, k, v)
mainopts.items.append(k)
self.main_setopts = mainopts
self.repo_setopts = repoopts
return bad_setopt_tm, bad_setopt_ne
def getOptionsConfig(self, args):
"""Parse command line arguments, and set up :attr:`self.conf` and
:attr:`self.cmds`, as well as logger objects in base instance.
:param args: a list of command line arguments
"""
self.optparser = YumOptionParser(base=self, usage=self._makeUsage())
# Parse only command line options that affect basic yum setup
opts = self.optparser.firstParse(args)
# Just print out the version if that's what the user wanted
if opts.version:
print yum.__version__
opts.quiet = True
opts.verbose = False
# go through all the setopts and set the global ones
bad_setopt_tm, bad_setopt_ne = self._parseSetOpts(opts.setopts)
if self.main_setopts:
for opt in self.main_setopts.items:
setattr(opts, opt, getattr(self.main_setopts, opt))
# get the install root to use
root = self.optparser.getRoot(opts)
if opts.quiet:
opts.debuglevel = 0
if opts.verbose:
opts.debuglevel = opts.errorlevel = 6
# Read up configuration options and initialise plugins
try:
pc = self.preconf
pc.fn = opts.conffile
pc.root = root
pc.init_plugins = not opts.noplugins
pc.plugin_types = (yum.plugins.TYPE_CORE,
yum.plugins.TYPE_INTERACTIVE)
pc.optparser = self.optparser
pc.debuglevel = opts.debuglevel
pc.errorlevel = opts.errorlevel
pc.disabled_plugins = self.optparser._splitArg(opts.disableplugins)
pc.enabled_plugins = self.optparser._splitArg(opts.enableplugins)
pc.releasever = opts.releasever
self.conf
for item in bad_setopt_tm:
msg = "Setopt argument has multiple values: %s"
self.logger.warning(msg % item)
for item in bad_setopt_ne:
msg = "Setopt argument has no value: %s"
self.logger.warning(msg % item)
# now set all the non-first-start opts from main from our setopts
if self.main_setopts:
for opt in self.main_setopts.items:
if not hasattr(self.conf, opt):
msg ="Main config did not have a %s attr. before setopt"
self.logger.warning(msg % opt)
setattr(self.conf, opt, getattr(self.main_setopts, opt))
except yum.Errors.ConfigError, e:
self.logger.critical(_('Config error: %s'), e)
sys.exit(1)
except IOError, e:
e = '%s: %s' % (to_unicode(e.args[1]), repr(e.filename))
self.logger.critical(_('Config error: %s'), e)
sys.exit(1)
except ValueError, e:
self.logger.critical(_('Options error: %s'), e)
sys.exit(1)
# update usage in case plugins have added commands
self.optparser.set_usage(self._makeUsage())
self.plugins.run('args', args=args)
# Now parse the command line for real and
# apply some of the options to self.conf
(opts, self.cmds) = self.optparser.setupYumConfig(args=args)
if opts.version:
opts.quiet = True
opts.verbose = False
# Check that firstParse didn't miss anything, and warn the user if it
# did ... because this is really magic, and unexpected.
if opts.quiet:
opts.debuglevel = 0
if opts.verbose:
opts.debuglevel = opts.errorlevel = 6
if opts.debuglevel != pc.debuglevel or opts.errorlevel != pc.errorlevel:
self.logger.warning(_("Ignored option -q, -v, -d or -e (probably due to merging: -yq != -y -q)"))
# getRoot() changes it, but then setupYumConfig() changes it back. So
# don't test for this, if we are using --installroot.
if root == '/' and opts.conffile != pc.fn:
self.logger.warning(_("Ignored option -c (probably due to merging -yc != -y -c)"))
if opts.version:
self.conf.cache = 1
yum_progs = self.run_with_package_names
done = False
def sm_ui_time(x):
return time.strftime("%Y-%m-%d %H:%M", time.gmtime(x))
def sm_ui_date(x): # For changelogs, there is no time
return time.strftime("%Y-%m-%d", time.gmtime(x))
for pkg in sorted(self.rpmdb.returnPackages(patterns=yum_progs)):
# We should only have 1 version of each...
if done: print ""
done = True
if pkg.epoch == '0':
ver = '%s-%s.%s' % (pkg.version, pkg.release, pkg.arch)
else:
ver = '%s:%s-%s.%s' % (pkg.epoch,
pkg.version, pkg.release, pkg.arch)
name = "%s%s%s" % (self.term.MODE['bold'], pkg.name,
self.term.MODE['normal'])
print _(" Installed: %s-%s at %s") %(name, ver,
sm_ui_time(pkg.installtime))
print _(" Built : %s at %s") % (to_unicode(pkg.packager),
sm_ui_time(pkg.buildtime))
print _(" Committed: %s at %s") % (to_unicode(pkg.committer),
sm_ui_date(pkg.committime))
sys.exit(0)
if opts.sleeptime is not None:
sleeptime = random.randrange(opts.sleeptime*60)
else:
sleeptime = 0
# save our original args out
self.args = args
# save out as a nice command string
self.cmdstring = 'yum '
for arg in self.args:
self.cmdstring += '%s ' % arg
try:
self.parseCommands() # before we return check over the base command + args
# make sure they match/make sense
except CliError:
sys.exit(1)
# run the sleep - if it's unchanged then it won't matter
time.sleep(sleeptime)
def parseCommands(self):
"""Read :attr:`self.cmds` and parse them out to make sure that
the requested base command and argument makes any sense at
all. This function will also set :attr:`self.basecmd` and
:attr:`self.extcmds`.
"""
self.verbose_logger.debug('Yum version: %s', yum.__version__)
self.verbose_logger.log(yum.logginglevels.DEBUG_4,
'COMMAND: %s', self.cmdstring)
self.verbose_logger.log(yum.logginglevels.DEBUG_4,
'Installroot: %s', self.conf.installroot)
if len(self.conf.commands) == 0 and len(self.cmds) < 1:
self.cmds = self.conf.commands
else:
self.conf.commands = self.cmds
if len(self.cmds) < 1:
self.logger.critical(_('You need to give some command'))
self.usage()
raise CliError
self.basecmd = self.cmds[0] # our base command
self.extcmds = self.cmds[1:] # out extended arguments/commands
if len(self.extcmds) > 0:
self.verbose_logger.log(yum.logginglevels.DEBUG_4,
'Ext Commands:\n')
for arg in self.extcmds:
self.verbose_logger.log(yum.logginglevels.DEBUG_4, ' %s', arg)
if self.basecmd not in self.yum_cli_commands:
self.logger.critical(_('No such command: %s. Please use %s --help'),
self.basecmd, sys.argv[0])
raise CliError
self._set_repos_cache_req()
self.yum_cli_commands[self.basecmd].doCheck(self, self.basecmd, self.extcmds)
def _set_repos_cache_req(self, warning=True):
""" Set the cacheReq attribute from the commands to the repos. """
cmd = self.yum_cli_commands[self.basecmd]
cacheReq = 'write'
if hasattr(cmd, 'cacheRequirement'):
cacheReq = cmd.cacheRequirement(self, self.basecmd, self.extcmds)
# The main thing we want to do here is that if the user has done a
# "yum makecache fast" or has yum-cron running or something, then try
# not to update the repo. caches ... thus. not turning 0.5s ops. into
# 100x longer ops.
# However if the repos. are not in sync. that's probably not going to
# work well (Eg. user enables updates-testing). Also give a warning if
# they are _really_ old.
ts_min = None
ts_max = None
for repo in self.repos.listEnabled():
if not os.path.exists(repo.metadata_cookie):
ts_min = None
break
rts = os.stat(repo.metadata_cookie).st_mtime
if not ts_min:
ts_min = rts
ts_max = rts
elif rts > ts_max:
ts_max = rts
elif rts < ts_min:
ts_min = rts
if ts_min:
# If caches are within 5 days of each other, they are ok to work
# together (lol, random numbers)...
if (ts_max - ts_min) > (60 * 60 * 24 * 5):
ts_min = None
elif ts_max > time.time():
ts_min = None
if not ts_min:
cacheReq = 'write'
all_obey = True
for repo in self.repos.sort():
repo._metadata_cache_req = cacheReq
if repo._matchExpireFilter():
all_obey = False
if warning and ts_min and (time.time() - ts_max) > (60 * 60 * 24 * 14):
# The warning makes no sense if we're already running a command
# that requires current repodata across all repos (such as "yum
# makecache" or others, depending on metadata_expire_filter), so
# don't give it if that's the case.
if all_obey:
return
self.logger.warning(_("Repodata is over 2 weeks old. Install yum-cron? Or run: yum makecache fast"))
def _shell_history_write(self):
if not hasattr(self, '_shell_history_cmds'):
return
if not self._shell_history_cmds:
return
data = self._shell_history_cmds
# Turn: [["a", "b"], ["c", "d"]] => "a b\nc d\n"
data = [" ".join(cmds) for cmds in data]
data.append('')
data = "\n".join(data)
self.history.write_addon_data('shell-cmds', data)
def doShell(self):
"""Run a shell-like interface for yum commands.
:return: a tuple containing the shell result number, and the
shell result messages
"""
yumshell = shell.YumShell(base=self)
# We share this array...
self._shell_history_cmds = yumshell._shell_history_cmds
if len(self.extcmds) == 0:
yumshell.cmdloop()
else:
yumshell.script()
del self._shell_history_cmds
return yumshell.result, yumshell.resultmsgs
def errorSummary(self, errstring):
"""Parse the error string for 'interesting' errors which can
be grouped, such as disk space issues.
:param errstring: the error string
:return: a string containing a summary of the errors
"""
summary = ''
# do disk space report first
p = re.compile('needs (\d+)(K|M)B on the (\S+) filesystem')
disk = {}
for m in p.finditer(errstring):
size_in_mb = int(m.group(1)) if m.group(2) == 'M' else math.ceil(int(m.group(1))/1024.0)
if m.group(3) not in disk:
disk[m.group(3)] = size_in_mb
if disk[m.group(3)] < size_in_mb:
disk[m.group(3)] = size_in_mb
if disk:
summary += _('Disk Requirements:\n')
for k in disk:
summary += P_(' At least %dMB more space needed on the %s filesystem.\n', ' At least %dMB more space needed on the %s filesystem.\n', disk[k]) % (disk[k], k)
# TODO: simplify the dependency errors?
# Fixup the summary
summary = _('Error Summary\n-------------\n') + summary
return summary
def waitForLock(self):
"""Establish the yum lock. If another process is already
holding the yum lock, by default this method will keep trying
to establish the lock until it is successful. However, if
:attr:`self.conf.exit_on_lock` is set to True, it will
raise a :class:`Errors.YumBaseError`.
"""
lockerr = ""
while True:
try:
self.doLock()
except yum.Errors.LockError, e:
if exception2msg(e) != lockerr:
lockerr = exception2msg(e)
self.logger.critical(lockerr)
if e.errno:
raise yum.Errors.YumBaseError, _("Can't create lock file; exiting")
if not self.conf.exit_on_lock:
self.logger.critical("Another app is currently holding the yum lock; waiting for it to exit...")
import utils
utils.show_lock_owner(e.pid, self.logger)
time.sleep(2)
else:
raise yum.Errors.YumBaseError, _("Another app is currently holding the yum lock; exiting as configured by exit_on_lock")
else:
break
def doCommands(self):
"""Call the base command, and pass it the extended commands or
arguments.
: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
"""
# at this point we know the args are valid - we don't know their meaning
# but we know we're not being sent garbage
# setup our transaction set if the command we're using needs it
# compat with odd modules not subclassing YumCommand
needTs = True
needTsRemove = False
cmd = self.yum_cli_commands[self.basecmd]
if hasattr(cmd, 'needTs'):
needTs = cmd.needTs(self, self.basecmd, self.extcmds)
if not needTs and hasattr(cmd, 'needTsRemove'):
needTsRemove = cmd.needTsRemove(self, self.basecmd, self.extcmds)
if needTs or needTsRemove:
try:
self._getTs(needTsRemove)
except yum.Errors.YumBaseError, e:
return 1, [exception2msg(e)]
# This should already have been done at doCheck() time, but just in
# case repos. got added or something do it again.
self._set_repos_cache_req(warning=False)
return self.yum_cli_commands[self.basecmd].doCommand(self, self.basecmd, self.extcmds)
def doTransaction(self):
"""Take care of package downloading, checking, user
confirmation and actually running the transaction.
:return: a numeric return code, and optionally a list of
errors. A negative return code indicates that errors
occurred in the pre-transaction checks
"""
def _downloadonly_userconfirm(self):
# Note that we shouldn't just remove the 'd' option, or the options
# yum accepts will be different which is bad. So always accept it,
# but change the prompt.
dl_only = {'downloadonly' :
(u'd', _('d'), _('download'),
_('downloadonly'))}
if not stuff_to_download:
ret = self.userconfirm(extra=dl_only)
if ret == 'downloadonly':
ret = None
return ret
return self.userconfirm(prompt=_('Is this ok [y/d/N]: '),
extra=dl_only)
# just make sure there's not, well, nothing to do
if len(self.tsInfo) == 0:
self.verbose_logger.info(_('Trying to run the transaction but nothing to do. Exiting.'))
return -1
# NOTE: In theory we can skip this in -q -y mode, for a slight perf.
# gain. But it's probably doom to have a different code path.
lsts = self.listTransaction()
if self.verbose_logger.isEnabledFor(yum.logginglevels.INFO_1):
self.verbose_logger.log(yum.logginglevels.INFO_1, lsts)
elif self.conf.assumeno or not self.conf.assumeyes:
# If we are in quiet, and assumeyes isn't on we want to output
# at least the transaction list anyway.
self.logger.warn(lsts)
# Check which packages have to be downloaded
downloadpkgs = []
rmpkgs = []
stuff_to_download = False
install_only = True
for txmbr in self.tsInfo.getMembers():
if txmbr.ts_state not in ('i', 'u'):
install_only = False
po = txmbr.po
if po:
rmpkgs.append(po)
else:
stuff_to_download = True
po = txmbr.po
if po:
downloadpkgs.append(po)
# Close the connection to the rpmdb so that rpm doesn't hold the SIGINT
# handler during the downloads. self.ts is reinitialised later in this
# function anyway (initActionTs).
self.ts.close()
# Report the total download size to the user, so he/she can base
# the answer on this info
if not stuff_to_download:
self.reportRemoveSize(rmpkgs)
else:
self.reportDownloadSize(downloadpkgs, install_only)
cfr = self.tsInfo._check_future_rpmdbv
if (cfr is not None and
self.tsInfo.futureRpmDBVersion() != cfr[1]):
msg = _("future rpmdb ver mismatched saved transaction version,")
if cfr[2]:
msg += _(" ignoring, as requested.")
self.logger.critical(_(msg))
else:
msg += _(" aborting.")
raise yum.Errors.YumBaseError(msg)
# confirm with user
if self._promptWanted():
uc = None
if not self.conf.assumeno:
uc = _downloadonly_userconfirm(self)
if not uc:
self.verbose_logger.info(_('Exiting on user command'))
return -1
elif uc == 'downloadonly':
self.conf.downloadonly = True
if self.conf.downloadonly:
self.verbose_logger.log(yum.logginglevels.INFO_2,
_('Background downloading packages, then exiting:'))
else:
self.verbose_logger.log(yum.logginglevels.INFO_2,
_('Downloading packages:'))
problems = self.downloadPkgs(downloadpkgs, callback_total=self.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
# Check GPG signatures
if self.gpgsigcheck(downloadpkgs) != 0:
return -1
self.initActionTs()
# save our dsCallback out
dscb = self.dsCallback
self.dsCallback = None # dumb, dumb dumb dumb!
self.populateTs(keepold=0) # sigh
rcd_st = time.time()
self.verbose_logger.log(yum.logginglevels.INFO_2,
_('Running transaction check'))
msgs = self._run_rpm_check()
depsolve = False
if msgs:
rpmlib_only = True
for msg in msgs:
if msg.startswith('rpmlib('):
continue
rpmlib_only = False
if rpmlib_only:
print _("ERROR You need to update rpm to handle:")
else:
print _('ERROR with transaction check vs depsolve:')
depsolve = True
for msg in msgs:
print to_utf8(msg)
if rpmlib_only:
return 1, [_('RPM needs to be updated')]
if depsolve:
return 1, []
else:
return 1, [_('Please report this error in %s') % self.conf.bugtracker_url]
self.verbose_logger.debug('Transaction check time: %0.3f' % (time.time() - rcd_st))
tt_st = time.time()
self.verbose_logger.log(yum.logginglevels.INFO_2,
_('Running transaction test'))
self.ts.order() # order the transaction
self.ts.clean() # release memory not needed beyond this point
testcb = RPMTransaction(self, test=True)
tserrors = self.ts.test(testcb)
del testcb
if len(tserrors) > 0:
errstring = _('Transaction check error:\n')
for descr in tserrors:
errstring += ' %s\n' % to_unicode(descr)
raise yum.Errors.YumBaseError, errstring + '\n' + \
self.errorSummary(errstring)
self.verbose_logger.log(yum.logginglevels.INFO_2,
_('Transaction test succeeded'))
self.verbose_logger.debug('Transaction test time: %0.3f' % (time.time() - tt_st))
# unset the sigquit handler
signal.signal(signal.SIGQUIT, signal.SIG_DFL)
ts_st = time.time()
# Reinstalls broke in: 7115478c527415cb3c8317456cdf50024de89a94 ...
# I assume there's a "better" fix, but this fixes reinstalls and lets
# other options continue as is (and they seem to work).
have_reinstalls = False
for txmbr in self.tsInfo.getMembers():
if txmbr.reinstall:
have_reinstalls = True
break
if have_reinstalls:
self.initActionTs() # make a new, blank ts to populate
self.populateTs(keepold=0) # populate the ts
self.ts.check() #required for ordering
self.ts.order() # order
self.ts.clean() # release memory not needed beyond this point
# put back our depcheck callback
self.dsCallback = dscb
# setup our rpm ts callback
cb = RPMTransaction(self,
display=output.YumCliRPMCallBack(weakref(self)))
if self.conf.debuglevel < 2:
cb.display.output = False
# Whenever we upgrade a shared library (and its dependencies) which the
# yum process itself may dlopen() post-transaction (e.g. in a plugin
# hook), we may end up in a situation where the upgraded library and
# the pre-transaction version of a library it depends on which is ABI
# incompatible are loaded in memory at the same time, leading to
# unpredictable behavior and possibly a crash. Let's avoid that by
# preloading all such dynamically loaded libraries pre-transaction so
# that dlopen(), if called post-transaction, uses those instead of
# loading the newly installed versions.
preload = {
# Loaded by libcurl, see BZ#1458841
'nss-sysinit': ['libnsssysinit.so'],
}
for pkg in preload:
# Only preload the libs if the package is actually installed and we
# are changing it with the transaction
if not self.tsInfo.matchNaevr(name=pkg) or \
not self.rpmdb.searchNevra(name=pkg):
continue
for lib in preload[pkg]:
try:
ctypes.cdll.LoadLibrary(lib)
self.verbose_logger.log(
yum.logginglevels.DEBUG_4,
_('Preloaded shared library %s') % lib
)
except Exception as e:
self.verbose_logger.log(
yum.logginglevels.DEBUG_4,
_('Could not preload shared library %s: %s') % (lib, e)
)
self.verbose_logger.log(yum.logginglevels.INFO_2, _('Running transaction'))
resultobject = self.runTransaction(cb=cb)
self.verbose_logger.debug('Transaction time: %0.3f' % (time.time() - ts_st))
# close things
self.verbose_logger.log(yum.logginglevels.INFO_1,
self.postTransactionOutput())
# put back the sigquit handler
signal.signal(signal.SIGQUIT, sigquit)
return resultobject.return_code
def gpgsigcheck(self, pkgs):
"""Perform GPG signature verification on the given packages,
installing keys if possible.
:param pkgs: a list of package objects to verify the GPG
signatures of
:return: non-zero if execution should stop due to an error
:raises: Will raise :class:`YumBaseError` if there's a problem
"""
for po in pkgs:
result, errmsg = self.sigCheckPkg(po)
if result == 0:
# Verified ok, or verify not req'd
continue
elif result == 1:
ay = self.conf.assumeyes and not self.conf.assumeno
if not sys.stdin.isatty() and not ay:
raise yum.Errors.YumBaseError, \
_('Refusing to automatically import keys when running ' \
'unattended.\nUse "-y" to override.')
# the callback here expects to be able to take options which
# userconfirm really doesn't... so fake it
self.getKeyForPackage(po, lambda x, y, z: self.userconfirm())
else:
# Fatal error
raise yum.Errors.YumBaseError, errmsg
return 0
def _maybeYouMeant(self, arg):
""" If install argument doesn't match with case, tell the user. """
matches = self.doPackageLists(patterns=[arg], ignore_case=True)
matches = matches.installed + matches.available
matches = set(map(lambda x: x.name, matches))
if matches:
msg = self.fmtKeyValFill(_(' * Maybe you meant: '),
", ".join(matches))
self.verbose_logger.log(yum.logginglevels.INFO_2, to_unicode(msg))
def _checkMaybeYouMeant(self, arg, always_output=True, rpmdb_only=False):
""" If the update/remove argument doesn't match with case, or due
to not being installed, tell the user. """
# always_output is a wart due to update/remove not producing the
# same output.
# if it is a grouppattern then none of this is going to make any sense
# skip it.
if not arg or arg[0] == '@':
return
pkgnarrow='all'
if rpmdb_only:
pkgnarrow='installed'
matches = self.doPackageLists(pkgnarrow=pkgnarrow, patterns=[arg], ignore_case=False)
if (matches.installed or (not matches.available and
self.returnInstalledPackagesByDep(arg))):
return # Found a match so ignore
hibeg = self.term.MODE['bold']
hiend = self.term.MODE['normal']
if matches.available:
self.verbose_logger.log(yum.logginglevels.INFO_2,
_('Package(s) %s%s%s available, but not installed.'),
hibeg, arg, hiend)
return
# No package name, so do the maybeYouMeant thing here too
matches = self.doPackageLists(pkgnarrow=pkgnarrow, patterns=[arg], ignore_case=True)
if not matches.installed and matches.available:
self.verbose_logger.log(yum.logginglevels.INFO_2,
_('Package(s) %s%s%s available, but not installed.'),
hibeg, arg, hiend)
return
matches = set(map(lambda x: x.name, matches.installed))
if always_output or matches:
self.verbose_logger.log(yum.logginglevels.INFO_2,
_('No package %s%s%s available.'),
hibeg, arg, hiend)
if matches:
msg = self.fmtKeyValFill(_(' * Maybe you meant: '),
", ".join(matches))
self.verbose_logger.log(yum.logginglevels.INFO_2, msg)
def _install_upgraded_requires(self, txmbrs):
"""Go through the given txmbrs, and for any to be installed packages
look for their installed deps. and try to upgrade them, if the
configuration is set. Returning any new transaction members to be
isntalled.
:param txmbrs: a list of :class:`yum.transactioninfo.TransactionMember` objects
:return: a list of :class:`yum.transactioninfo.TransactionMember` objects
"""
if not self.conf.upgrade_requirements_on_install:
return []
ret = []
done = set()
def _pkg2ups(pkg, reqpo=None):
if pkg.name in done:
return []
if reqpo is None:
reqpo = pkg
done.add(pkg.name)
uret = []
for req in pkg.requires:
for npkg in self.returnInstalledPackagesByDep(req):
if npkg.name in done:
continue
uret += self.update(name=npkg.name, requiringPo=reqpo)
uret += _pkg2ups(npkg, reqpo=reqpo)
return uret
for txmbr in txmbrs:
for rtxmbr, T in txmbr.relatedto:
ret += _pkg2ups(rtxmbr)
ret += _pkg2ups(txmbr.po)
return ret
def installPkgs(self, userlist, basecmd='install', repoid=None):
"""Attempt to take the user specified list of packages or
wildcards and install them, or if they are installed, update
them to a newer version. If a complete version number is
specified, attempt to upgrade (or downgrade if they have been
removed) them to the specified version.
:param userlist: a list of names or wildcards specifying
packages to install
: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
"""
# get the list of available packages
# iterate over the user's list
# add packages to Transaction holding class if they match.
# if we've added any packages to the transaction then return 2 and a string
# if we've hit a snag, return 1 and the failure explanation
# if we've got nothing to do, return 0 and a 'nothing available to install' string
oldcount = len(self.tsInfo)
done = False
for arg in userlist:
if (arg.endswith('.rpm') and (yum.misc.re_remote_url(arg) or
os.path.exists(arg))):
txmbrs = self.installLocal(arg)
self._install_upgraded_requires(txmbrs)
continue # it was something on disk and it ended in rpm
# no matter what we don't go looking at repos
try:
if False: pass
elif basecmd == 'install-n':
txmbrs = self.install(name=arg)
elif basecmd == 'install-na':
try:
n,a = arg.rsplit('.', 1)
except:
self.verbose_logger.warning(_('Bad %s argument %s.'),
basecmd, arg)
if not self.conf.skip_missing_names_on_install:
return 1, [_('Not tolerating missing names on install, stopping.')]
continue
txmbrs = self.install(name=n, arch=a)
elif basecmd == 'install-nevra':
try:
nevr,a = arg.rsplit('.', 1)
n,ev,r = nevr.rsplit('-', 2)
e,v = ev.split(':', 1)
except:
self.verbose_logger.warning(_('Bad %s argument %s.'),
basecmd, arg)
if not self.conf.skip_missing_names_on_install:
return 1, [_('Not tolerating missing names on install, stopping.')]
continue
txmbrs = self.install(name=n,
epoch=e, version=v, release=r, arch=a)
else:
assert basecmd == 'install', basecmd
txmbrs = self.install(pattern=arg)
except yum.Errors.GroupInstallError, e:
self.verbose_logger.log(yum.logginglevels.INFO_2, e)
if not self.conf.skip_missing_names_on_install:
return 1, [_('Not tolerating missing names on install, stopping.')]
except yum.Errors.InstallError:
self.verbose_logger.log(yum.logginglevels.INFO_2,
_('No package %s%s%s available.'),
self.term.MODE['bold'], arg,
self.term.MODE['normal'])
self._maybeYouMeant(arg)
if not self.conf.skip_missing_names_on_install:
return 1, [_('Not tolerating missing names on install, stopping.')]
else:
done = True
self._install_upgraded_requires(txmbrs)
if len(self.tsInfo) > oldcount:
change = len(self.tsInfo) - oldcount
return 2, [P_('%d package to install', '%d packages to install', change) % change]
if not done:
return 1, [_('Nothing to do')]
return 0, [_('Nothing to do')]
def updatePkgs(self, userlist, quiet=0, update_to=False):
"""Take user commands and populate transaction wrapper with
packages to be updated.
:param userlist: a list of names or wildcards specifying
packages to update. If *userlist* is an empty list, yum
will perform a global update
:param quiet: unused
:param update_to: if *update_to* is True, the update will only
be run if it will update the given package to the given
version. For example, if the package foo-1-2 is installed,
updatePkgs(["foo-1-2], update_to=False) will work
identically to updatePkgs(["foo"]), but
updatePkgs(["foo-1-2"], update_to=True) will do nothing
: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 there is no userlist, then do global update below
# this is probably 90% of the calls
# if there is a userlist then it's for updating pkgs, not obsoleting
oldcount = len(self.tsInfo)
if len(userlist) == 0: # simple case - do them all
self.update()
else:
# go through the userlist - look for items that are local rpms. If we find them
# pass them off to installLocal() and then move on
for item in userlist:
if (item.endswith('.rpm') and (yum.misc.re_remote_url(item) or
os.path.exists(item))):
txmbrs = self.installLocal(item, updateonly=1)
self._install_upgraded_requires(txmbrs)
continue
try:
txmbrs = self.update(pattern=item, update_to=update_to)
except (yum.Errors.UpdateMissingNameError, yum.Errors.GroupInstallError):
self._checkMaybeYouMeant(item)
return 1, [_('Not tolerating missing names on update, stopping.')]
self._install_upgraded_requires(txmbrs)
if not txmbrs:
self._checkMaybeYouMeant(item)
if not self.conf.skip_missing_names_on_update:
matches = self.doPackageLists(pkgnarrow='all', patterns=[item], ignore_case=False)
if matches.available and not matches.installed:
return 1, [_('Not tolerating missing names on update, stopping.')]
if len(self.tsInfo) > oldcount:
change = len(self.tsInfo) - oldcount
return 2, [P_('%d package marked for update', '%d packages marked for update', change) % change]
else:
return 0, [_('No packages marked for update')]
# Note that we aren't in __init__ yet for a couple of reasons, but we
# probably will get there for 3.2.28.
def distroSyncPkgs(self, userlist):
"""Upgrade or downgrade packages to match the latest versions
available in the enabled repositories.
:param userlist: list of names or wildcards specifying
packages to synchronize with the repositories. If the
first string in *userlist* is "full", packages will also be
reinstalled if their checksums do not match the checksums
in the repositories. If *userlist* is an empty list or
only contains "full", every installed package will be
synchronized
: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
"""
level = 'diff'
if userlist and userlist[0] in ('full', 'diff', 'different'):
level = userlist[0]
userlist = userlist[1:]
if level == 'different':
level = 'diff'
dupdates = []
ipkgs = {}
for pkg in sorted(self.rpmdb.returnPackages(patterns=userlist)):
ipkgs[pkg.name] = pkg
obsoletes = []
if self.conf.obsoletes:
obsoletes = self.up.getObsoletesTuples(newest=1)
for (obsoleting, installed) in obsoletes:
if installed[0] not in ipkgs:
continue
dupdates.extend(self.update(pkgtup=installed))
for (obsoleting, installed) in obsoletes:
if installed[0] not in ipkgs:
continue
del ipkgs[installed[0]]
apkgs = {}
pkgs = []
if ipkgs:
try:
pkgs = self.pkgSack.returnNewestByName(patterns=ipkgs.keys())
except yum.Errors.PackageSackError:
pkgs = []
for pkg in pkgs:
if pkg.name not in ipkgs:
continue
apkgs[pkg.name] = pkg
for ipkgname in ipkgs:
if ipkgname not in apkgs:
continue
ipkg = ipkgs[ipkgname]
apkg = apkgs[ipkgname]
if ipkg.verEQ(apkg): # Latest installed == Latest avail.
if level == 'diff':
continue
# level == full: do reinstalls if checksum doesn't match.
# do removals, if older installed versions.
for napkg in self.rpmdb.searchNames([ipkgname]):
if (not self.allowedMultipleInstalls(apkg) and
not napkg.verEQ(ipkg)):
dupdates.extend(self.remove(po=napkg))
continue
nayi = napkg.yumdb_info
found = False
for apkg in self.pkgSack.searchPkgTuple(napkg.pkgtup):
if ('checksum_type' in nayi and
'checksum_data' in nayi and
nayi.checksum_type == apkg.checksum_type and
nayi.checksum_data == apkg.pkgId):
found = True
break
if found:
continue
dupdates.extend(self.reinstall(pkgtup=napkg.pkgtup))
continue
if self.allowedMultipleInstalls(apkg):
found = False
for napkg in self.rpmdb.searchNames([apkg.name]):
if napkg.verEQ(apkg):
found = True
elif napkg.verGT(apkg):
dupdates.extend(self.remove(po=napkg))
if found:
continue
dupdates.extend(self.install(pattern=apkg.name))
elif ipkg.verLT(apkg):
n,a,e,v,r = apkg.pkgtup
dupdates.extend(self.update(name=n, epoch=e, ver=v, rel=r))
else:
n,a,e,v,r = apkg.pkgtup
dupdates.extend(self.downgrade(name=n, epoch=e, ver=v, rel=r))
if dupdates:
return 2, [P_('%d package marked for distribution synchronization', '%d packages marked for distribution synchronization', len(dupdates)) % len(dupdates)]
else:
return 0, [_('No packages marked for distribution synchronization')]
def erasePkgs(self, userlist, pos=False, basecmd='remove'):
"""Take user commands and populate a transaction wrapper with
packages to be erased.
:param userlist: a list of names or wildcards specifying
packages to erase
: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
"""
all_rms = []
for arg in userlist:
if pos:
rms = self.remove(po=arg)
if rms:
all_rms.extend(rms)
continue
if False: pass
elif basecmd in ('erase-n', 'remove-n'):
rms = self.remove(name=arg)
elif basecmd in ('erase-na', 'remove-na'):
try:
n,a = arg.rsplit('.', 1)
except:
self.verbose_logger.warning(_('Bad %s argument %s.'),
basecmd, arg)
continue
rms = self.remove(name=n, arch=a)
elif basecmd in ('erase-nevra', 'remove-nevra'):
try:
nevr,a = arg.rsplit('.', 1)
n,ev,r = nevr.rsplit('-', 2)
e,v = ev.split(':', 1)
except:
self.verbose_logger.warning(_('Bad %s argument %s.'),
basecmd, arg)
continue
rms = self.remove(name=n, epoch=e, version=v, release=r, arch=a)
else:
assert basecmd in ('erase', 'remove'), basecmd
rms = self.remove(pattern=arg)
if not rms:
self._checkMaybeYouMeant(arg, always_output=False, rpmdb_only=True)
all_rms.extend(rms)
if all_rms:
return 2, [P_('%d package marked for removal', '%d packages marked for removal', len(all_rms)) % len(all_rms)]
else:
return 0, [_('No Packages marked for removal')]
def downgradePkgs(self, userlist):
"""Attempt to take the user specified list of packages or
wildcards and downgrade them. If a complete version number if
specified, attempt to downgrade them to the specified version
:param userlist: a list of names or wildcards specifying
packages to downgrade
: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
"""
oldcount = len(self.tsInfo)
done = False
for arg in userlist:
if (arg.endswith('.rpm') and (yum.misc.re_remote_url(arg) or
os.path.exists(arg))):
self.downgradeLocal(arg)
continue # it was something on disk and it ended in rpm
# no matter what we don't go looking at repos
try:
self.downgrade(pattern=arg)
except yum.Errors.DowngradeError:
self.verbose_logger.log(yum.logginglevels.INFO_2,
_('No package %s%s%s available.'),
self.term.MODE['bold'], arg,
self.term.MODE['normal'])
self._maybeYouMeant(arg)
else:
done = True
if len(self.tsInfo) > oldcount:
change = len(self.tsInfo) - oldcount
return 2, [P_('%d package to downgrade', '%d packages to downgrade', change) % change]
if not done:
return 1, [_('Nothing to do')]
return 0, [_('Nothing to do')]
def reinstallPkgs(self, userlist):
"""Attempt to take the user specified list of packages or
wildcards and reinstall them.
:param userlist: a list of names or wildcards specifying
packages to reinstall
: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
"""
oldcount = len(self.tsInfo)
done = False
for arg in userlist:
if (arg.endswith('.rpm') and (yum.misc.re_remote_url(arg) or
os.path.exists(arg))):
txmbrs = self.reinstallLocal(arg)
self._install_upgraded_requires(txmbrs)
continue # it was something on disk and it ended in rpm
# no matter what we don't go looking at repos
try:
txmbrs = self.reinstall(pattern=arg)
except yum.Errors.ReinstallRemoveError:
self._checkMaybeYouMeant(arg, always_output=False)
except yum.Errors.ReinstallInstallError, e:
for ipkg in e.failed_pkgs:
xmsg = ''
if 'from_repo' in ipkg.yumdb_info:
xmsg = ipkg.yumdb_info.from_repo
xmsg = _(' (from %s)') % xmsg
msg = _('Installed package %s%s%s%s not available.')
self.verbose_logger.log(yum.logginglevels.INFO_2, msg,
self.term.MODE['bold'], ipkg,
self.term.MODE['normal'], xmsg)
except yum.Errors.ReinstallError, e:
assert False, "Shouldn't happen, but just in case"
self.verbose_logger.log(yum.logginglevels.INFO_2, e)
else:
done = True
self._install_upgraded_requires(txmbrs)
if len(self.tsInfo) > oldcount:
change = len(self.tsInfo) - oldcount
return 2, [P_('%d package to reinstall', '%d packages to reinstall', change) % change]
if not done:
return 1, [_('Nothing to do')]
return 0, [_('Nothing to do')]
def localInstall(self, filelist, updateonly=0):
"""Install or update rpms provided on the file system in a
local directory (i.e. not from a repository).
:param filelist: a list of names specifying local rpms
: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
"""
# read in each package into a YumLocalPackage Object
# append it to self.localPackages
# check if it can be installed or updated based on nevra versus rpmdb
# don't import the repos until we absolutely need them for depsolving
if len(filelist) == 0:
return 0, [_('No packages provided')]
installing = False
for pkg in filelist:
if not pkg.endswith('.rpm'):
self.verbose_logger.log(yum.logginglevels.INFO_2,
"Skipping: %s, filename does not end in .rpm.", pkg)
continue
txmbrs = self.installLocal(pkg, updateonly=updateonly)
if txmbrs:
installing = True
if installing:
return 2, [_('Package(s) to install')]
return 0, [_('Nothing to do')]
def returnPkgLists(self, extcmds, installed_available=False, repoid=None):
"""Return a :class:`yum.misc.GenericHolder` object containing
lists of package objects that match the given names or wildcards.
:param extcmds: a list of names or wildcards specifying
packages to list
:param installed_available: whether the available package list
is present as .hidden_available when doing all, available,
or installed
:param repoid: a repoid that all packages should belong to
:return: a :class:`yum.misc.GenericHolder` instance with the
following lists defined::
available = list of packageObjects
installed = list of packageObjects
updates = tuples of packageObjects (updating, installed)
extras = list of packageObjects
obsoletes = tuples of packageObjects (obsoleting, installed)
recent = list of packageObjects
"""
special = ['available', 'installed', 'all', 'extras', 'updates', 'recent',
'obsoletes', 'distro-extras']
pkgnarrow = 'all'
done_hidden_available = False
done_hidden_installed = False
if len(extcmds) > 0:
if installed_available and extcmds[0] == 'installed':
done_hidden_available = True
extcmds.pop(0)
elif installed_available and extcmds[0] == 'available':
done_hidden_installed = True
extcmds.pop(0)
elif extcmds[0] in special:
pkgnarrow = extcmds.pop(0)
ypl = self.doPackageLists(pkgnarrow=pkgnarrow, patterns=extcmds,
ignore_case=True, repoid=repoid)
if self.conf.showdupesfromrepos:
ypl.available += ypl.reinstall_available
if installed_available:
ypl.hidden_available = ypl.available
ypl.hidden_installed = ypl.installed
if done_hidden_available:
ypl.available = []
if done_hidden_installed:
ypl.installed = []
return ypl
def search(self, args):
"""Search for simple text tags in a package object. This is a
cli wrapper method for the module search function.
:param args: list of names or wildcards to search for.
Normally this method will begin by searching the package
names and summaries, and will only search urls and
descriptions if that fails. However, if the first string
in *args* is "all", this method will always search
everything
:return: a tuple where the first item is an exit code, and
the second item is a generator if the search is a
successful, and a list of error messages otherwise
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
"""
# call the yum module search function with lists of tags to search
# and what to search for
# display the list of matches
searchlist = ['name', 'summary', 'description', 'url']
dups = self.conf.showdupesfromrepos
args = map(to_unicode, args)
okeys = set()
akeys = set() # All keys, used to see if nothing matched
mkeys = set() # "Main" set of keys for N/S search (biggest term. hit).
pos = set()
def _print_match_section(text):
# Print them in the order they were passed
used_keys = [arg for arg in args if arg in keys]
print self.fmtSection(text % ", ".join(used_keys))
# First try just the name/summary fields, and if we get any hits
# don't do the other stuff. Unless the user overrides via. "all".
if len(args) > 1 and args[0] == 'all':
args.pop(0)
else:
matching = self.searchGenerator(['name', 'summary'], args,
showdups=dups, keys=True)
for (po, keys, matched_value) in matching:
if keys != okeys:
if akeys:
if len(mkeys) == len(args):
break
print ""
else:
mkeys = set(keys)
_print_match_section(_('N/S matched: %s'))
okeys = keys
pos.add(po)
akeys.update(keys)
self.matchcallback(po, matched_value, args)
matching = self.searchGenerator(searchlist, args,
showdups=dups, keys=True)
okeys = set()
# If we got a hit with just name/summary then we only care about hits
# with _more_ search terms. Thus. if we hit all our search terms. do
# nothing.
if len(mkeys) == len(args):
print ""
if len(args) == 1:
msg = _(' Name and summary matches %sonly%s, use "search all" for everything.')
else:
msg = _(' Full name and summary matches %sonly%s, use "search all" for everything.')
print msg % (self.term.MODE['bold'], self.term.MODE['normal'])
matching = []
for (po, keys, matched_value) in matching:
# Don't print matches for "a", "b", "c" on N+S+D when we already
# matched that on just N+S.
if len(keys) <= len(mkeys):
continue
# Just print the highest level of full matches, when we did
# minimal matches. Ie. "A", "B" match N+S, just print the
# "A", "B", "C", "D" full match, and not the "B", "C", "D" matches.
if mkeys and len(keys) < len(okeys):
continue
if keys != okeys:
if akeys:
print ""
_print_match_section(_('Matched: %s'))
okeys = keys
akeys.update(keys)
self.matchcallback(po, matched_value, args)
if mkeys and len(mkeys) != len(args):
print ""
print _(' Name and summary matches %smostly%s, use "search all" for everything.') % (self.term.MODE['bold'], self.term.MODE['normal'])
for arg in args:
if arg not in akeys:
self.logger.warning(_('Warning: No matches found for: %s'), arg)
if not akeys:
return 0, [_('No matches found')]
return 0, matching
def deplist(self, args):
"""Print out a formatted list of dependencies for a list of
packages. This is a cli wrapper method for
:class:`yum.YumBase.findDeps`.
:param args: a list of names or wildcards specifying packages
that should have their dependenices printed
: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
"""
pkgs = []
for arg in args:
if (arg.endswith('.rpm') and (yum.misc.re_remote_url(arg) or
os.path.exists(arg))):
thispkg = yum.packages.YumUrlPackage(self, self.ts, arg)
pkgs.append(thispkg)
elif self.conf.showdupesfromrepos:
pkgs.extend(self.pkgSack.returnPackages(patterns=[arg],
ignore_case=True))
else:
try:
pkgs.extend(self.pkgSack.returnNewestByName(patterns=[arg],
ignore_case=True))
except yum.Errors.PackageSackError:
pass
results = self.findDeps(pkgs)
self.depListOutput(results)
return 0, []
def provides(self, args):
"""Print out a list of packages that provide the given file or
feature. This a cli wrapper to the provides methods in the
rpmdb and pkgsack.
:param args: the name of a file or feature to search for
: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
"""
old_sdup = self.conf.showdupesfromrepos
# For output, as searchPackageProvides() is always in showdups mode
self.conf.showdupesfromrepos = True
cb = self.matchcallback_verbose
matching = self.searchPackageProvides(args, callback=cb,
callback_has_matchfor=True)
if len(matching) == 0:
# Try to be a bit clever, for commands, and python modules.
# Maybe want something so we can do perl/etc. too?
paths = set(sys.path + os.environ['PATH'].split(':'))
nargs = []
for arg in args:
if not arg:
continue
if yum.misc.re_filename(arg) or yum.misc.re_glob(arg):
continue
for path in paths:
if not path:
continue
nargs.append("%s/%s" % (path, arg))
matching = self.searchPackageProvides(nargs, callback=cb,
callback_has_matchfor=True)
self.conf.showdupesfromrepos = old_sdup
if len(matching) == 0:
return 0, ['No matches found']
return 0, []
def resolveDepCli(self, args):
"""Print information about a package that provides the given
dependency. Only one package will be printed per dependency.
:param args: a list of strings specifying dependencies to
search for
: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
"""
not_found = set()
for arg in args:
try:
ipkg = self.returnInstalledPackageByDep(arg)
except yum.Errors.YumBaseError:
ipkg = None
else:
self.verbose_logger.info(" %s:", arg)
self.verbose_logger.info("%s %s" % (ipkg.envra,
ipkg.ui_from_repo))
try:
pkg = self.returnPackageByDep(arg)
except yum.Errors.YumBaseError:
if not ipkg:
not_found.add(arg)
else:
if not ipkg:
self.verbose_logger.info(" %s:", arg)
if not pkg.verEQ(ipkg):
self.verbose_logger.info("%s %s" % (pkg.envra,
pkg.ui_from_repo))
if not_found:
self.logger.critical(_('Error: No packages found for:\n %s'),
"\n ".join(sorted(not_found)))
return 0, []
def cleanCli(self, userlist):
"""Remove data from the yum cache directory. What data is
removed depends on the options supplied by the user.
:param userlist: a list of options. The following are valid
options::
expire-cache = Eliminate the local data saying when the
metadata and mirror lists were downloaded for each
repository.
packages = Eliminate any cached packages
headers = Eliminate the header files, which old versions
of yum used for dependency resolution
metadata = Eliminate all of the files which yum uses to
determine the remote availability of packages
dbcache = Eliminate the sqlite cache used for faster
access to metadata
rpmdb = Eliminate any cached datat from the local rpmdb
plugins = Tell any enabled plugins to eliminate their
cached data
all = do all of the above
: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
"""
hdrcode = pkgcode = xmlcode = dbcode = expccode = 0
pkgresults = hdrresults = xmlresults = dbresults = expcresults = []
msg = self.fmtKeyValFill(_('Cleaning repos: '),
' '.join([ x.id for x in self.repos.listEnabled()]))
self.verbose_logger.log(yum.logginglevels.INFO_2, msg)
msg = (_('Operating on %s (see CLEAN OPTIONS in yum(8) for details)')
% self.conf.cachedir)
self.verbose_logger.log(yum.logginglevels.DEBUG_3, msg)
if 'all' in userlist:
pkgcode, pkgresults = self.cleanPackages()
hdrcode, hdrresults = self.cleanHeaders()
xmlcode, xmlresults = self.cleanMetadata()
dbcode, dbresults = self.cleanSqlite()
rpmcode, rpmresults = self.cleanRpmDB()
self.plugins.run('clean')
code = hdrcode + pkgcode + xmlcode + dbcode + rpmcode
results = (hdrresults + pkgresults + xmlresults + dbresults +
rpmresults)
for msg in results:
self.logger.debug(msg)
# Walk the cachedir, look for any leftovers and categorize them
cacheglob = self.getCachedirGlob(['basearch', 'releasever'])
paths = glob.glob(cacheglob + '/*')
table = ([], [], [], []) # (enabled, disabled, untracked, other)
repos = self.repos.repos
empty = True
for path in paths:
base = os.path.basename(path)
if os.path.isdir(path):
# Repodir
if base not in repos:
col = 2
elif repos[base].enabled:
col = 0
else:
col = 1
else:
# Ordinary file (such as timedhosts)
col = 3
usage = yum.misc.disk_usage(path)
if not usage:
continue
table[col].append((usage, path))
# Detect any uncleaned data.
#
# We never remove directories or any unrecognized repodata
# files, so there always will be a few kilobytes left behind.
# To avoid a constant false alarm, let's ignore such files if
# they are really tiny (such as "productid"). The easiest way
# is to look at "usage" as it covers both directories and
# files. Given that a typical cleaned repodir (4K) consists of
# the gen/ (4K) and packages/ (4K) subdirs and possibly the
# productid file (8K), let's "round" it up to 64K and use that
# as our threshold.
if col < 3 and usage > 64*1024:
empty = False
# Print the table (verbose mode only)
lines = [_('Disk usage under %s after cleanup:') % cacheglob]
headers = ('enabled repos', 'disabled repos', 'untracked repos',
'other data')
totals = [0, 0, 0, 0]
for col, header in enumerate(headers):
rows = []
total = 0
# Start with the biggest items
for usage, path in sorted(table[col], key=lambda x:x[0],
reverse=True):
rows.append(' %-5s %s'
% (self.format_number(usage), path))
total += usage
colon = ':' if rows else ''
lines += ['%-5s %s%s'
% (self.format_number(total), _(header), colon)]
lines += rows
totals[col] = total
lines += [_('%-5s total') % self.format_number(sum(totals))]
msg = '\n'.join(lines)
self.verbose_logger.log(yum.logginglevels.DEBUG_3, msg)
# Print a short hint if leftover repos are found (non-verbose mode
# only).
if empty or self.conf.debuglevel == 6:
return code, []
total = self.format_number(sum(totals[:3]))
if total[-1] == ' ':
total = total[:-1] + 'bytes'
msg = (_('Other repos take up %s of disk space '
'(use --verbose for details)') % total)
self.verbose_logger.log(yum.logginglevels.INFO_2, msg)
return code, []
if 'headers' in userlist:
self.logger.debug(_('Cleaning up headers'))
hdrcode, hdrresults = self.cleanHeaders()
if 'packages' in userlist:
self.logger.debug(_('Cleaning up packages'))
pkgcode, pkgresults = self.cleanPackages()
if 'metadata' in userlist:
self.logger.debug(_('Cleaning up xml metadata'))
xmlcode, xmlresults = self.cleanMetadata()
if 'dbcache' in userlist or 'metadata' in userlist:
self.logger.debug(_('Cleaning up database cache'))
dbcode, dbresults = self.cleanSqlite()
if 'expire-cache' in userlist or 'metadata' in userlist:
self.logger.debug(_('Cleaning up expire-cache metadata'))
expccode, expcresults = self.cleanExpireCache()
if 'rpmdb' in userlist:
self.logger.debug(_('Cleaning up cached rpmdb data'))
expccode, expcresults = self.cleanRpmDB()
if 'plugins' in userlist:
self.logger.debug(_('Cleaning up plugins'))
self.plugins.run('clean')
code = hdrcode + pkgcode + xmlcode + dbcode + expccode
results = hdrresults + pkgresults + xmlresults + dbresults + expcresults
for msg in results:
self.verbose_logger.log(yum.logginglevels.INFO_2, msg)
return code, []
def returnGroupLists(self, userlist):
"""Print out a list of groups that match the given names or
wildcards.
:param extcmds: a list of names or wildcards specifying
groups to list
: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 self._returnGroupLists(userlist)
def _returnGroupLists(self, userlist, summary=False):
# What data are we showing...
wts_map = {'hidden' : 'hidden',
'language' : 'lang',
'languages' : 'lang',
'lang' : 'lang',
'langs' : 'lang',
'environment' : 'env',
'environments' : 'env',
'env' : 'env',
'envs' : 'env',
'package' : 'pkg',
'packages' : 'pkg',
'pkg' : 'pkg',
'pkgs' : 'pkg',
'available' : 'avail',
'avail' : 'avail',
'installed' : 'inst',
'inst' : 'inst',
'id' : 'id',
'ids' : 'id',
}
verb = self.verbose_logger.isEnabledFor(yum.logginglevels.DEBUG_3)
wts = {'hidden' : False,
'lang' : None,
'env' : None,
'pkg' : None,
'inst' : None,
'avail' : None,
'id' : verb}
ouserlist = userlist[:]
while userlist:
arg = userlist[0]
val = True
if arg.startswith('no'):
arg = arg[2:]
val = False
if arg not in wts_map:
break
wts[wts_map[arg]] = val
userlist.pop(0)
if not userlist:
userlist = None # Match everything...
if wts['inst'] is None and wts['avail'] is None:
wts['inst'] = True
wts['avail'] = True
if wts['lang'] is None and wts['pkg'] is None and wts['env'] is None:
wts['env'] = True
wts['pkg'] = True
uv = not wts['hidden']
dGL = self.doGroupLists(patterns=userlist,
uservisible=uv, return_evgrps=True)
installed, available, ievgrps, evgrps = dGL
if not wts['env']:
ievgrps = []
evgrps = []
if not wts['inst']:
installed = []
ievgrps = []
if not wts['avail']:
available = []
evgrps = []
done = []
def _out_grp(sect, groups):
if not groups:
return
done.append(sect)
if summary:
self.verbose_logger.log(yum.logginglevels.INFO_2,
"%s %u", sect, len(groups))
return
self.verbose_logger.log(yum.logginglevels.INFO_2, sect)
for group in groups:
msg = ' %s' % group.ui_name
if wts['id']:
msg += ' (%s)' % group.compsid
if group.langonly:
msg += ' [%s]' % group.langonly
self.verbose_logger.info('%s', msg)
_out_grp(_('Installed Environment Groups:'), ievgrps)
_out_grp(_('Available Environment Groups:'), evgrps)
groups = []
for group in installed:
if group.langonly: continue
if not wts['pkg']: continue
groups.append(group)
_out_grp(_('Installed Groups:'), groups)
groups = []
for group in installed:
if not group.langonly: continue
if not wts['lang']: continue
groups.append(group)
_out_grp(_('Installed Language Groups:'), groups)
groups = []
for group in available:
if group.langonly: continue
if not wts['pkg']: continue
groups.append(group)
_out_grp(_('Available Groups:'), groups)
groups = []
for group in available:
if not group.langonly: continue
if not wts['lang']: continue
groups.append(group)
_out_grp(_('Available Language Groups:'), groups)
if not done:
self.logger.error(_('Warning: no environments/groups match: %s'),
", ".join(ouserlist))
return 0, []
return 0, [_('Done')]
def returnGroupSummary(self, userlist):
"""Print a summary of the groups that match the given names or
wildcards.
:param userlist: a list of names or wildcards specifying the
groups to summarise. If *userlist* is an empty list, all
installed and available packages will be summarised
: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 self._returnGroupLists(userlist, summary=True)
def returnGroupInfo(self, userlist):
"""Print complete information about the groups that match the
given names or wildcards.
:param userlist: a list of names or wildcards specifying the
groups to print information about
: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
"""
for strng in userlist:
group_matched = False
pkg_grp = True
grp_grp = True
if strng.startswith('@^'):
strng = strng[2:]
pkg_grp = False
elif strng.startswith('@'):
strng = strng[1:]
grp_grp = False
if grp_grp:
for evgroup in self.comps.return_environments(strng):
self.displayGrpsInEnvironments(evgroup)
group_matched = True
if pkg_grp:
for group in self.comps.return_groups(strng):
self.displayPkgsInGroups(group)
group_matched = True
if not group_matched:
self.logger.error(_('Warning: group/environment %s does not exist.'), strng)
return 0, []
def installGroups(self, grouplist, upgrade=False):
"""Mark the packages in the given groups for installation.
:param grouplist: a list of names or wildcards specifying
groups to be installed
: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
"""
pkgs_used = []
if not grouplist and self.conf.group_command == 'objects':
# Do what "yum upgrade" does when upgrade_group_objects_upgrade is
# set.
for ievgrp in self.igroups.environments:
pkgs_used.extend(self._at_groupupgrade('@^' + ievgrp))
for igrp in self.igroups.groups:
pkgs_used.extend(self._at_groupupgrade('@' + igrp))
done = False
for group_string in grouplist:
grp_grp = True
pkg_grp = True
if group_string.startswith('@^'):
pkg_grp = False
group_string = group_string[2:]
elif group_string.startswith('@'):
grp_grp = False
group_string = group_string[1:]
group_matched = False
groups = []
if grp_grp:
groups = self.comps.return_environments(group_string)
for group in groups:
group_matched = True
try:
txmbrs = self.selectEnvironment(group.environmentid,
upgrade=upgrade)
except yum.Errors.GroupsError:
self.logger.critical(_('Warning: Environment group %s does not exist.'), group_string)
continue
else:
pkgs_used.extend(txmbrs)
groups = []
if pkg_grp:
groups = self.comps.return_groups(group_string)
for group in groups:
group_matched = True
try:
txmbrs = self.selectGroup(group.groupid, upgrade=upgrade)
except yum.Errors.GroupsError:
self.logger.critical(_('Warning: Package group %s does not exist.'), group_string)
continue
else:
pkgs_used.extend(txmbrs)
if not group_matched:
self.logger.error(_('Warning: group %s does not exist.'), group_string)
continue
done = True
if not pkgs_used:
if self.conf.group_command == 'objects':
self.logger.critical(_("Maybe run: yum groups mark install (see man yum)"))
exit_status = 1
if upgrade:
# upgrades don't fail
exit_status = 0
if done:
# at least one group_string was a valid group
exit_status = 0
return exit_status, [_('No packages in any requested group available to install or update')]
else:
return 2, [P_('%d package to Install', '%d packages to Install', len(pkgs_used)) % len(pkgs_used)]
def removeGroups(self, grouplist):
"""Mark the packages in the given groups for removal.
:param grouplist: a list of names or wildcards specifying
groups to be removed
: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
"""
pkgs_used = []
for group_string in grouplist:
grp_grp = True
pkg_grp = True
if group_string.startswith('@^'):
pkg_grp = False
group_string = group_string[2:]
elif group_string.startswith('@'):
grp_grp = False
group_string = group_string[1:]
groups = []
if grp_grp:
groups = self.comps.return_environments(group_string)
if not groups:
self.logger.critical(_('No environment named %s exists'), group_string)
for group in groups:
try:
txmbrs = self.environmentRemove(group.environmentid)
except yum.Errors.GroupsError:
continue
else:
pkgs_used.extend(txmbrs)
groups = []
if pkg_grp:
groups = self.comps.return_groups(group_string)
if not groups:
self.logger.critical(_('No group named %s exists'), group_string)
for group in groups:
try:
txmbrs = self.groupRemove(group.groupid)
except yum.Errors.GroupsError:
continue
else:
pkgs_used.extend(txmbrs)
if not pkgs_used:
if self.conf.group_command == 'objects':
self.logger.critical(_("Maybe run: yum groups mark remove (see man yum)"))
return 0, [_('No packages to remove from groups')]
else:
return 2, [P_('%d package to remove', '%d packages to remove', len(pkgs_used)) % len(pkgs_used)]
def _promptWanted(self):
# shortcut for the always-off/always-on options
if (self.conf.assumeyes or self.conf.downloadonly) and not self.conf.assumeno:
return False
if self.conf.alwaysprompt:
return True
# prompt if:
# package was added to fill a dependency
# package is being removed
# package wasn't explicitly given on the command line
for txmbr in self.tsInfo.getMembers():
if txmbr.isDep or \
txmbr.name not in self.extcmds:
return True
# otherwise, don't prompt
return False
def usage(self):
"""Print out an explanation of command line usage."""
sys.stdout.write(self.optparser.format_help())
def shellUsage(self):
"""Print out an explanation of the shell usage."""
sys.stdout.write(self.optparser.get_usage())
def _installable(self, pkg, ematch=False):
"""check if the package is reasonably installable, true/false"""
exactarchlist = self.conf.exactarchlist
# we look through each returned possibility and rule out the
# ones that we obviously can't use
if self.rpmdb.contains(po=pkg):
self.verbose_logger.log(yum.logginglevels.DEBUG_3,
_('Package %s is already installed, skipping'), pkg)
return False
# everything installed that matches the name
installedByKey = self.rpmdb.searchNevra(name=pkg.name)
comparable = []
for instpo in installedByKey:
if isMultiLibArch(instpo.arch) == isMultiLibArch(pkg.arch):
comparable.append(instpo)
else:
self.verbose_logger.log(yum.logginglevels.DEBUG_3,
_('Discarding non-comparable pkg %s.%s'), instpo.name, instpo.arch)
continue
# go through each package
if len(comparable) > 0:
for instpo in comparable:
if pkg.verGT(instpo): # we're newer - this is an update, pass to them
if instpo.name in exactarchlist:
if pkg.arch == instpo.arch:
return True
else:
return True
elif pkg.verEQ(instpo): # same, ignore
return False
elif pkg.verLT(instpo): # lesser, check if the pkgtup is an exactmatch
# if so then add it to be installed
# if it can be multiply installed
# this is where we could handle setting
# it to be an 'oldpackage' revert.
if ematch and self.allowedMultipleInstalls(pkg):
return True
else: # we've not got any installed that match n or n+a
self.verbose_logger.log(yum.logginglevels.DEBUG_1, _('No other %s installed, adding to list for potential install'), pkg.name)
return True
return False
class YumOptionParser(OptionParser):
"""Subclass that makes some minor tweaks to make OptionParser do things the
"yum way".
"""
def __init__(self,base, **kwargs):
# check if this is called with a utils=True/False parameter
if 'utils' in kwargs:
self._utils = kwargs['utils']
del kwargs['utils']
else:
self._utils = False
OptionParser.__init__(self, **kwargs)
self.logger = logging.getLogger("yum.cli")
self.base = base
self.plugin_option_group = OptionGroup(self, _("Plugin Options"))
self.add_option_group(self.plugin_option_group)
self._addYumBasicOptions()
def error(self, msg):
"""Output an error message, and exit the program. This method
is overridden so that error output goes to the logger.
:param msg: the error message to output
"""
self.print_usage()
self.logger.critical(_("Command line error: %s"), msg)
sys.exit(1)
def firstParse(self,args):
"""Parse only command line options that affect basic yum
setup.
:param args: a list of command line options to parse
:return: a dictionary containing the values of command line
options
"""
try:
args = _filtercmdline(
('--noplugins','--version','-q', '-v', "--quiet", "--verbose"),
('-c', '--config', '-d', '--debuglevel',
'-e', '--errorlevel',
'--installroot',
'--disableplugin', '--enableplugin', '--releasever',
'--setopt'),
args)
except ValueError, arg:
self.base.usage()
print >> sys.stderr, (_("\n\n%s: %s option requires an argument") %
('Command line error', arg))
sys.exit(1)
return self.parse_args(args=args)[0]
@staticmethod
def _splitArg(seq):
""" Split all strings in seq, at "," and whitespace.
Returns a new list. """
ret = []
for arg in seq:
ret.extend(arg.replace(",", " ").split())
return ret
def setupYumConfig(self, args=None):
"""Parse command line options.
:param args: the command line arguments entered by the user
:return: (opts, cmds) opts is a dictionary containing
the values of command line options. cmds is a list of the
command line arguments that were not parsed as options.
For example, if args is ["install", "foo", "--verbose"],
cmds will be ["install", "foo"].
"""
if not args:
(opts, cmds) = self.parse_args()
else:
(opts, cmds) = self.parse_args(args=args)
# Let the plugins know what happened on the command line
self.base.plugins.setCmdLine(opts, cmds)
try:
# config file is parsed and moving us forward
# set some things in it.
if opts.tolerant or self.base.conf.tolerant: # Make it slower capt.
self.base.conf.recheck_installed_requires = True
# Handle remaining options
if opts.assumeyes:
self.base.conf.assumeyes = 1
if opts.assumeno:
self.base.conf.assumeno = 1
self.base.conf.downloadonly = opts.dlonly
self.base.conf.downloaddir = opts.dldir
# Store all the updateinfo filters somewhere...
self.base.updateinfo_filters['security'] = opts.security
self.base.updateinfo_filters['bugfix'] = opts.bugfix
self.base.updateinfo_filters['advs'] = self._splitArg(opts.advs)
self.base.updateinfo_filters['bzs'] = self._splitArg(opts.bzs)
self.base.updateinfo_filters['cves'] = self._splitArg(opts.cves)
self.base.updateinfo_filters['sevs'] = self._splitArg(opts.sevs)
if not self.base.conf.usercache and os.geteuid() != 0:
self.base.conf.cache = 1
# Treat users like root as much as possible:
elif not self.base.setCacheDir():
self.base.conf.cache = 1
if opts.cacheonly:
self.base.conf.cache = 1
if opts.obsoletes:
self.base.conf.obsoletes = 1
if opts.installroot:
self._checkAbsInstallRoot(opts)
self.base.conf.installroot = opts.installroot
if opts.skipbroken:
self.base.conf.skip_broken = True
if opts.showdupesfromrepos:
self.base.conf.showdupesfromrepos = True
if opts.color not in (None, 'auto', 'always', 'never',
'tty', 'if-tty', 'yes', 'no', 'on', 'off'):
raise ValueError, _("--color takes one of: auto, always, never")
elif opts.color is None:
if self.base.conf.color != 'auto':
self.base.term.reinit(color=self.base.conf.color)
else:
_remap = {'tty' : 'auto', 'if-tty' : 'auto',
'1' : 'always', 'true' : 'always',
'yes' : 'always', 'on' : 'always',
'0' : 'always', 'false' : 'always',
'no' : 'never', 'off' : 'never'}
opts.color = _remap.get(opts.color, opts.color)
if opts.color != 'auto':
self.base.term.reinit(color=opts.color)
self.base.conf.disable_excludes = self._splitArg(opts.disableexcludes)
self.base.conf.disable_includes = self._splitArg(opts.disableincludes)
self.base.cmdline_excludes = self._splitArg(opts.exclude)
for exclude in self.base.cmdline_excludes:
try:
excludelist = self.base.conf.exclude
excludelist.append(exclude)
self.base.conf.exclude = excludelist
except yum.Errors.ConfigError, e:
self.logger.critical(e)
self.base.usage()
sys.exit(1)
if opts.rpmverbosity is not None:
self.base.conf.rpmverbosity = opts.rpmverbosity
# setup the progress bars/callbacks
self.base.setupProgressCallbacks()
# setup the callbacks to import gpg pubkeys and confirm them
self.base.setupKeyImportCallbacks()
# Process repo enables and disables in order
for opt, repoexp in opts.repos:
try:
if opt == '--enablerepo':
self.base.repos.enableRepo(repoexp)
elif opt == '--disablerepo':
self.base.repos.disableRepo(repoexp)
except yum.Errors.ConfigError, e:
self.logger.critical(e)
self.base.usage()
sys.exit(1)
# Disable all gpg key checking, if requested.
if opts.nogpgcheck:
# Altering the normal configs. doesn't work too well, esp. with
# regard to dynamically enabled repos.
self.base._override_sigchecks = True
for repo in self.base.repos.listEnabled():
repo._override_sigchecks = True
except ValueError, e:
self.logger.critical(_('Options error: %s'), e)
self.base.usage()
sys.exit(1)
return opts, cmds
def _checkAbsInstallRoot(self, opts):
if not opts.installroot:
return
if opts.installroot[0] == '/':
return
# We have a relative installroot ... haha
self.logger.critical(_('--installroot must be an absolute path: %s'),
opts.installroot)
sys.exit(1)
def getRoot(self,opts):
"""Return the root location to use for the yum operation.
This location can be changed by using the --installroot
option.
:param opts: a dictionary containing the values of the command
line options
:return: a string representing the root location
"""
self._checkAbsInstallRoot(opts)
# If the conf file is inside the installroot - use that.
# otherwise look for it in the normal root
if opts.installroot and opts.installroot.lstrip('/'):
if os.access(opts.installroot+'/'+opts.conffile, os.R_OK):
opts.conffile = opts.installroot+'/'+opts.conffile
elif opts.conffile == '/etc/yum/yum.conf':
# check if /installroot/etc/yum.conf exists.
if os.access(opts.installroot+'/etc/yum.conf', os.R_OK):
opts.conffile = opts.installroot+'/etc/yum.conf'
root=opts.installroot
else:
root = '/'
return root
def _wrapOptParseUsage(self, opt, value, parser, *args, **kwargs):
self.base.usage()
self.exit()
def _addYumBasicOptions(self):
def repo_optcb(optobj, opt, value, parser):
'''Callback for the enablerepo and disablerepo option.
Combines the values given for these options while preserving order
from command line.
'''
dest = eval('parser.values.%s' % optobj.dest)
dest.append((opt, value))
if self._utils:
group = OptionGroup(self, "Yum Base Options")
self.add_option_group(group)
else:
group = self
# Note that we can't use the default action="help" because of the
# fact that print_help() unconditionally does .encode() ... which is
# bad on unicode input.
group.conflict_handler = "resolve"
group.add_option("-h", "--help", action="callback",
callback=self._wrapOptParseUsage,
help=_("show this help message and exit"))
group.conflict_handler = "error"
group.add_option("-t", "--tolerant", action="store_true",
help=_("be tolerant of errors"))
group.add_option("-C", "--cacheonly", dest="cacheonly",
action="store_true",
help=_("run entirely from system cache, don't update cache"))
group.add_option("-c", "--config", dest="conffile",
default='/etc/yum/yum.conf',
help=_("config file location"), metavar='[config file]')
group.add_option("-R", "--randomwait", dest="sleeptime", type='int',
default=None,
help=_("maximum command wait time"), metavar='[minutes]')
group.add_option("-d", "--debuglevel", dest="debuglevel", default=None,
help=_("debugging output level"), type='int',
metavar='[debug level]')
group.add_option("--showduplicates", dest="showdupesfromrepos",
action="store_true",
help=_("show duplicates, in repos, in list/search commands"))
group.add_option("--show-duplicates", dest="showdupesfromrepos",
action="store_true",
help=SUPPRESS_HELP)
group.add_option("-e", "--errorlevel", dest="errorlevel", default=None,
help=_("error output level"), type='int',
metavar='[error level]')
group.add_option("", "--rpmverbosity", default=None,
help=_("debugging output level for rpm"),
metavar='[debug level name]')
group.add_option("-q", "--quiet", dest="quiet", action="store_true",
help=_("quiet operation"))
group.add_option("-v", "--verbose", dest="verbose", action="store_true",
help=_("verbose operation"))
group.add_option("-y", "--assumeyes", dest="assumeyes",
action="store_true", help=_("answer yes for all questions"))
group.add_option("--assumeno", dest="assumeno",
action="store_true", help=_("answer no for all questions"))
group.add_option("--nodeps", dest="assumeno", # easter egg :)
action="store_true", help=SUPPRESS_HELP)
group.add_option("--version", action="store_true",
help=_("show Yum version and exit"))
group.add_option("--installroot", help=_("set install root"),
metavar='[path]')
group.add_option("--enablerepo", action='callback',
type='string', callback=repo_optcb, dest='repos', default=[],
help=_("enable one or more repositories (wildcards allowed)"),
metavar='[repo]')
group.add_option("--disablerepo", action='callback',
type='string', callback=repo_optcb, dest='repos', default=[],
help=_("disable one or more repositories (wildcards allowed)"),
metavar='[repo]')
group.add_option("-x", "--exclude", default=[], action="append",
help=_("exclude package(s) by name or glob"), metavar='[package]')
group.add_option("", "--disableexcludes", default=[], action="append",
help=_("disable exclude from main, for a repo or for everything"),
metavar='[repo]')
group.add_option("", "--disableincludes", default=[], action="append",
help=_("disable includepkgs for a repo or for everything"),
metavar='[repo]')
group.add_option("--obsoletes", action="store_true",
help=_("enable obsoletes processing during updates"))
group.add_option("--noplugins", action="store_true",
help=_("disable Yum plugins"))
group.add_option("--nogpgcheck", action="store_true",
help=_("disable gpg signature checking"))
group.add_option("", "--disableplugin", dest="disableplugins", default=[],
action="append", help=_("disable plugins by name"),
metavar='[plugin]')
group.add_option("", "--enableplugin", dest="enableplugins", default=[],
action="append", help=_("enable plugins by name"),
metavar='[plugin]')
group.add_option("--skip-broken", action="store_true", dest="skipbroken",
help=_("skip packages with depsolving problems"))
group.add_option("", "--color", dest="color", default=None,
help=_("control whether color is used"))
group.add_option("", "--releasever", dest="releasever", default=None,
help=_("set value of $releasever in yum config and repo files"))
group.add_option("--downloadonly", dest="dlonly", action="store_true",
help=_("don't update, just download"))
group.add_option("--downloaddir", dest="dldir", default=None,
help=_("specifies an alternate directory to store packages"))
group.add_option("", "--setopt", dest="setopts", default=[],
action="append", help=_("set arbitrary config and repo options"))
# Updateinfo options...
group.add_option("--bugfix", action="store_true",
help=_("Include bugfix relevant packages, in updates"))
group.add_option("--security", action="store_true",
help=_("Include security relevant packages, in updates"))
group.add_option("--advisory", "--advisories", dest="advs", default=[],
action="append", help=_("Include packages needed to fix the given advisory, in updates"))
group.add_option("--bzs", default=[],
action="append", help=_("Include packages needed to fix the given BZ, in updates"))
group.add_option("--cves", default=[],
action="append", help=_("Include packages needed to fix the given CVE, in updates"))
group.add_option("--sec-severity", "--secseverity", default=[],
dest="sevs", action="append",
help=_("Include security relevant packages matching the severity, in updates"))
def _filtercmdline(novalopts, valopts, args):
'''Keep only specific options from the command line argument list
This function allows us to peek at specific command line options when using
the optparse module. This is useful when some options affect what other
options should be available.
@param novalopts: A sequence of options to keep that don't take an argument.
@param valopts: A sequence of options to keep that take a single argument.
@param args: The command line arguments to parse (as per sys.argv[:1]
@return: A list of strings containing the filtered version of args.
Will raise ValueError if there was a problem parsing the command line.
'''
# ' xemacs syntax hack
out = []
args = list(args) # Make a copy because this func is destructive
while len(args) > 0:
a = args.pop(0)
if '=' in a:
opt, _ = a.split('=', 1)
if opt in valopts:
out.append(a)
elif a == '--':
out.append(a)
elif a in novalopts:
out.append(a)
elif a in valopts:
if len(args) < 1:
raise ValueError, a
next = args.pop(0)
if next[0] == '-':
raise ValueError, a
out.extend([a, next])
else:
# Check for single letter options that take a value, where the
# value is right up against the option
for opt in valopts:
if len(opt) == 2 and a.startswith(opt):
out.append(a)
return out
Mini Shell