anvil/tools/yyoom
Joshua Harlow 9fb0ef1b79 Ensure install/uninstall correctness
- Give the yyoom command the versions to install.
- Correctly find the versions after building them.
- Ensure the os-spec files have the rpm version dependencies.

Change-Id: Ic4e3771032792c37c8d945bc2c288e593852fc27
2013-07-26 23:24:15 -07:00

319 lines
10 KiB
Python
Executable File

#!/usr/bin/python
# 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
# Parts Copyright 2007 Red Hat, Inc
"""YYOOM: a package management utility
Using Yum API instead of /usr/bin/yum provides several interesting
capabilities, some of which we are desperate to use, including:
- installing and removing packages in same transaction;
- JSON output.
"""
import argparse
import json
import logging
import os
import sys
import yum
from contextlib import contextmanager
LOG = logging.getLogger('yyoom')
OUTPUT = None
def _setup_output():
"""Do some nasty manipulations with fds
Yum internals may sometimes write to stdout, just out of a sudden.
To prevent this output form interfering with our JSON, we save
current stdout to other fd via os.dup, and replace fd 1 with
/dev/null opened for writing.
"""
global OUTPUT
# save current stdout for later use
OUTPUT = os.fdopen(os.dup(sys.stdout.fileno()), 'wb')
# close the stream
sys.stdout.close()
# open /dev/null -- all writes to stdout from now on will go there
devnull_fd = os.open(os.devnull, os.O_WRONLY)
if devnull_fd != 1:
os.dup2(devnull_fd, 1)
os.close(devnull_fd)
sys.stdout = os.fdopen(1, 'w')
def _write_output(data):
"""Dump given object as pretty json"""
OUTPUT.write(json.dumps(data, indent=4,
separators=(',', ': '),
sort_keys=True) + '\n')
def _package_info(pkg, **kwargs):
if isinstance(pkg, basestring):
result = dict(name=pkg, **kwargs)
else:
result = dict(
name=pkg.name,
epoch=pkg.epoch,
version=pkg.version,
release=pkg.release,
provides=pkg.provides,
repo=str(pkg.repo),
arch=pkg.arch,
**kwargs
)
return result
class _RPMCallback(yum.rpmtrans.RPMBaseCallback):
"""Listen to events from RPM transactions"""
def __init__(self):
self.seen = []
def event(self, package, action, te_current, te_total,
ts_current, ts_total):
pass
def scriptout(self, package, msg):
if not msg or not LOG.isEnabledFor(logging.INFO):
return
for line in msg.splitlines():
line = line.strip()
if line:
LOG.info("%s: %s", package, line)
def errorlog(self, msg):
LOG.error("%s", msg)
def filelog(self, package, action):
action_data = _package_info(package, action_code=action)
if action in yum.constants.TS_INSTALL_STATES:
action_data['action_type'] = 'install'
elif action in yum.constants.TS_REMOVE_STATES:
action_data['action_type'] = 'erase'
else:
action_data['action_type'] = 'other'
self.seen.append(action_data)
LOG.info("Performed %(action_type)s (code %(action_code)s) on %(name)s"
% action_data)
def log_list(items, title=''):
if not items:
return
if title:
if not title.endswith(':'):
title = str(title) + ":"
LOG.info(title)
for i in items:
LOG.info(" - %s" % (i))
def _run(yum_base, options):
"""Handler of `transaction` command
Installs and erases packages, prints what was done in JSON
"""
def parse_package(p):
pkg_info = {}
try:
(name, version) = p.split(',', 1)
pkg_info['name'] = name
if version:
pkg_info['version'] = version
except ValueError:
pkg_info['name'] = p
return pkg_info
log_list(options.erase, title='Erasing packages:')
log_list(options.install, title='Installing packages:')
callback = _RPMCallback()
with _transaction(yum_base, callback):
for pkg in options.erase or ():
pkg = parse_package(pkg)
yum_base.remove(**pkg)
for pkg in options.install or ():
pkg = parse_package(pkg)
yum_base.install(**pkg)
_write_output(callback.seen)
def _list(yum_base, options):
"""Handler of `list` command"""
pkgnarrow = options.what[0] if len(options.what) == 1 else 'all'
lists = yum_base.doPackageLists(pkgnarrow=pkgnarrow, showdups=True)
LOG.debug("Got packages for '%s': %s installed, %s available,"
"%s available for reinstall, %s extras",
pkgnarrow, len(lists.installed), len(lists.available),
len(lists.reinstall_available), len(lists.extras))
result = []
if 'installed' in options.what:
result.extend(_package_info(pkg, status='installed')
for pkg in lists.installed)
if 'available' in options.what:
result.extend(_package_info(pkg, status='available')
for pkg in lists.available)
result.extend(_package_info(pkg, status='available')
for pkg in lists.reinstall_available)
if 'extras' in options.what:
result.extend(_package_info(pkg, status='installed')
for pkg in lists.extras)
_write_output(result)
def _cleanall(yum_base, options):
"""Handler of `cleanall` command"""
LOG.info("Running yum cleanup")
code = sum((
_run_yum_api('packages clean up', yum_base.cleanPackages),
_run_yum_api('headers clean up', yum_base.cleanHeaders),
_run_yum_api('metadata clean up', yum_base.cleanMetadata),
_run_yum_api('sqlite clean up', yum_base.cleanSqlite),
_run_yum_api('rpm db clean up', yum_base.cleanRpmDB),
))
return code
def _builddep(yum_base, options):
"""Handler of `builddep` command
Installs build dependencies for given package, prints what was done
in JSON.
"""
LOG.info("Installing build dependencies for package %s", options.srpm)
srpm = yum.packages.YumLocalPackage(yum_base.ts, options.srpm)
callback = _RPMCallback()
with _transaction(yum_base, callback):
for req in srpm.requiresList():
LOG.debug('Processing dependency: %s', req)
if not (
req.startswith('rpmlib(') or
yum_base.returnInstalledPackagesByDep(req)
):
pkg = yum_base.returnPackageByDep(req)
LOG.debug('Installing %s', pkg)
yum_base.install(pkg)
_write_output(callback.seen)
def _parse_arguments(args):
parser = argparse.ArgumentParser(prog=args[0])
parser.add_argument('--verbose', '-v', action='store_true',
help='verbose operation')
# TODO(imelnikov): --format
subparsers = parser.add_subparsers(title='subcommands')
parser_list = subparsers.add_parser('list', help='list packages')
parser_list.add_argument('what', nargs='+',
choices=('installed', 'available', 'extras'),
help='what packages to list')
parser_list.set_defaults(func=_list)
parser_run = subparsers.add_parser('transaction',
help='install or remove packages')
parser_run.set_defaults(func=_run)
parser_run.add_argument('--install', '-i', action='append',
metavar='package',
help='install package')
parser_run.add_argument('--erase', '-e', action='append',
metavar='package',
help='erase package')
parser_builddep = subparsers.add_parser(
'builddep', help='install build dependencies of srpm')
parser_builddep.add_argument('srpm', help='path to source RPM package')
parser_builddep.set_defaults(func=_builddep)
parser_cleanall = subparsers.add_parser('cleanall', help='clean all')
parser_cleanall.set_defaults(func=_cleanall)
return parser.parse_args(args[1:])
def _setup_logging(verbose=True):
"""Initialize logging"""
# setup logging -- put messages to stderr
handler = logging.StreamHandler(sys.stderr)
handler.setFormatter(logging.Formatter('YYOOM %(levelname)s: %(message)s'))
root_logger = logging.getLogger()
root_logger.addHandler(handler)
root_logger.setLevel(logging.DEBUG if verbose else logging.INFO)
def _get_yum_base():
base = yum.YumBase()
base.setCacheDir(force=True)
# See: http://lists.baseurl.org/pipermail/yum-devel/2013-January/009873.html
base._override_sigchecks = True
return base
def _run_yum_api(name, func, ok_codes=(0,), *args, **kwargs):
code, results = func(*args, **kwargs)
for msg in results:
LOG.debug(msg)
if code not in ok_codes:
LOG.error('%s failed', name.title())
return code
@contextmanager
def _transaction(base, callback):
"""Manage Yum transactions
Locks and unlocks Yum database, builds and processes transaction
on __exit__.
"""
try:
base.doLock()
yield
code = _run_yum_api('building transaction',
base.buildTransaction, ok_codes=(0, 2))
if code == 0:
LOG.debug('Nothing to do')
elif code == 2:
base.processTransaction(rpmTestDisplay=callback,
rpmDisplay=callback)
else:
raise RuntimeError("Transaction failed: %s" % code)
finally:
del base.tsInfo
del base.ts
base.doUnlock()
def main(args):
options = _parse_arguments(args)
try:
_setup_output()
_setup_logging(options.verbose)
return options.func(_get_yum_base(), options) or 0
except Exception as e:
if options.verbose:
raise # let python runtime write stacktrace
sys.stderr.write("Failed: %s\n" % e)
return 1
if __name__ == '__main__':
sys.exit(main(sys.argv))