????
Your IP : 18.117.11.13
# repodiff.py
# DNF plugin adding a command to show differencies between two sets
# of repositories.
#
# Copyright (C) 2018 Red Hat, Inc.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions of
# the GNU General Public License v.2, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY expressed or implied, including the implied warranties of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 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., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the
# source code or documentation are not subject to the GNU General Public
# License and may only be used or replicated with the express permission of
# Red Hat, Inc.
#
from __future__ import absolute_import
from __future__ import unicode_literals
import dnf.cli
from dnf.cli.option_parser import OptionParser
import hawkey
from dnfpluginscore import _
class RepoDiff(dnf.Plugin):
name = "repodiff"
def __init__(self, base, cli):
super(RepoDiff, self).__init__(base, cli)
if cli is None:
return
cli.register_command(RepoDiffCommand)
class RepoDiffCommand(dnf.cli.Command):
aliases = ("repodiff",)
summary = _("List differences between two sets of repositories")
@staticmethod
def set_argparser(parser):
# I'd like to use --old and --new options like Yum did.
# But ability to disable abbreviated long options is added
# only in Python >= 3.5
# So in command arguments we are not able to use arguments,
# which are prefixes of main arguments (i.w. --new would be
# treated as --newpackage). This is because we run .parse_args
# two times - for main and then for command arguments.
# https://stackoverflow.com/questions/33900846
parser.add_argument("--repo-old", "-o", default=[], action="append", dest="old",
help=_("Specify old repository, can be used multiple times"))
parser.add_argument("--repo-new", "-n", default=[], action="append", dest="new",
help=_("Specify new repository, can be used multiple times"))
parser.add_argument("--arch", "--archlist", "-a", default=[],
action=OptionParser._SplitCallback, dest="arches",
help=_("Specify architectures to compare, can be used "
"multiple times. By default, only source rpms are "
"compared."))
parser.add_argument("--size", "-s", action="store_true",
help=_("Output additional data about the size of the changes."))
parser.add_argument("--compare-arch", action="store_true",
help=_("Compare packages also by arch. By default "
"packages are compared just by name."))
parser.add_argument("--simple", action="store_true",
help=_("Output a simple one line message for modified packages."))
parser.add_argument("--downgrade", action="store_true",
help=_("Split the data for modified packages between "
"upgraded and downgraded packages."))
def configure(self):
demands = self.cli.demands
demands.sack_activation = True
demands.available_repos = True
demands.changelogs = True
self.base.conf.disable_excludes = ["all"]
# TODO yum was able to handle mirrorlist in --new/--old arguments
# Can be resolved by improving --repofrompath option
if not self.opts.new or not self.opts.old:
msg = _("Both old and new repositories must be set.")
raise dnf.exceptions.Error(msg)
for repo in self.base.repos.all():
if repo.id in self.opts.new + self.opts.old:
repo.enable()
else:
repo.disable()
if not self.opts.arches:
self.opts.arches = ['src']
def _pkgkey(self, pkg):
if self.opts.compare_arch:
return (pkg.name, pkg.arch)
return pkg.name
def _repodiff(self, old, new):
'''compares packagesets old and new, returns dictionary with packages:
added: only in new set
removed: only in old set
upgraded: in both old and new, new has bigger evr
downgraded: in both old and new, new has lower evr
obsoletes: dictionary of which old package is obsoleted by which new
'''
old_d = dict([(self._pkgkey(p), p) for p in old])
old_keys = set(old_d.keys())
new_d = dict([(self._pkgkey(p), p) for p in new])
new_keys = set(new_d.keys())
# mapping obsoleted_package_from_old: obsoleted_by_package_from_new
obsoletes = dict()
for obsoleter in new.filter(obsoletes=old):
for obsoleted in old.filter(provides=obsoleter.obsoletes):
obsoletes[self._pkgkey(obsoleted)] = obsoleter
evr_cmp = self.base.sack.evr_cmp
repodiff = dict(
added=[new_d[k] for k in new_keys - old_keys],
removed=[old_d[k] for k in old_keys - new_keys],
obsoletes=obsoletes,
upgraded=[],
downgraded=[])
for k in old_keys.intersection(new_keys):
pkg_old = old_d[k]
pkg_new = new_d[k]
if pkg_old.evr == pkg_new.evr:
continue
if evr_cmp(pkg_old.evr, pkg_new.evr) > 0:
repodiff['downgraded'].append((pkg_old, pkg_new))
else:
repodiff['upgraded'].append((pkg_old, pkg_new))
return repodiff
def _report(self, repodiff):
def pkgstr(pkg):
if self.opts.compare_arch:
return str(pkg)
return "%s-%s" % (pkg.name, pkg.evr)
def sizestr(num):
msg = str(num)
if num > 0:
msg += " ({})".format(dnf.cli.format.format_number(num).strip())
elif num < 0:
msg += " (-{})".format(dnf.cli.format.format_number(-num).strip())
return msg
def report_modified(pkg_old, pkg_new):
msgs = []
if self.opts.simple:
msgs.append("%s -> %s" % (pkgstr(pkg_old), pkgstr(pkg_new)))
else:
msgs.append('')
msgs.append("%s -> %s" % (pkgstr(pkg_old), pkgstr(pkg_new)))
msgs.append('-' * len(msgs[-1]))
if pkg_old.changelogs:
old_chlog = pkg_old.changelogs[0]
else:
old_chlog = None
for chlog in pkg_new.changelogs:
if old_chlog:
if chlog['timestamp'] < old_chlog['timestamp']:
break
elif (chlog['timestamp'] == old_chlog['timestamp'] and
chlog['author'] == old_chlog['author'] and
chlog['text'] == old_chlog['text']):
break
msgs.append('* %s %s\n%s' % (
chlog['timestamp'].strftime("%a %b %d %Y"),
dnf.i18n.ucd(chlog['author']),
dnf.i18n.ucd(chlog['text'])))
if self.opts.size:
msgs.append(_("Size change: {} bytes").format(
pkg_new.size - pkg_old.size))
print('\n'.join(msgs))
sizes = dict(added=0, removed=0, upgraded=0, downgraded=0)
for pkg in sorted(repodiff['added']):
print(_("Added package : {}").format(pkgstr(pkg)))
sizes['added'] += pkg.size
for pkg in sorted(repodiff['removed']):
print(_("Removed package: {}").format(pkgstr(pkg)))
obsoletedby = repodiff['obsoletes'].get(self._pkgkey(pkg))
if obsoletedby:
print(_("Obsoleted by : {}").format(pkgstr(obsoletedby)))
sizes['removed'] += pkg.size
if self.opts.downgrade:
if repodiff['upgraded']:
print(_("\nUpgraded packages"))
for (pkg_old, pkg_new) in sorted(repodiff['upgraded']):
sizes['upgraded'] += (pkg_new.size - pkg_old.size)
report_modified(pkg_old, pkg_new)
if repodiff['downgraded']:
print(_("\nDowngraded packages"))
for (pkg_old, pkg_new) in sorted(repodiff['downgraded']):
sizes['downgraded'] += (pkg_new.size - pkg_old.size)
report_modified(pkg_old, pkg_new)
else:
modified = repodiff['upgraded'] + repodiff['downgraded']
if modified:
print(_("\nModified packages"))
for (pkg_old, pkg_new) in sorted(modified):
sizes['upgraded'] += (pkg_new.size - pkg_old.size)
report_modified(pkg_old, pkg_new)
print(_("\nSummary"))
print(_("Added packages: {}").format(len(repodiff['added'])))
print(_("Removed packages: {}").format(len(repodiff['removed'])))
if self.opts.downgrade:
print(_("Upgraded packages: {}").format(len(repodiff['upgraded'])))
print(_("Downgraded packages: {}").format(len(repodiff['downgraded'])))
else:
print(_("Modified packages: {}").format(
len(repodiff['upgraded']) + len(repodiff['downgraded'])))
if self.opts.size:
print(_("Size of added packages: {}").format(sizestr(sizes['added'])))
print(_("Size of removed packages: {}").format(sizestr(sizes['removed'])))
if not self.opts.downgrade:
print(_("Size of modified packages: {}").format(
sizestr(sizes['upgraded'] + sizes['downgraded'])))
else:
print(_("Size of upgraded packages: {}").format(
sizestr(sizes['upgraded'])))
print(_("Size of downgraded packages: {}").format(
sizestr(sizes['downgraded'])))
print(_("Size change: {}").format(
sizestr(sizes['added'] + sizes['upgraded'] + sizes['downgraded'] -
sizes['removed'])))
def run(self):
# prepare old and new packagesets based by given arguments
q_new = self.base.sack.query(hawkey.IGNORE_EXCLUDES).filter(
reponame=self.opts.new)
q_old = self.base.sack.query(hawkey.IGNORE_EXCLUDES).filter(
reponame=self.opts.old)
if self.opts.arches and '*' not in self.opts.arches:
q_new.filterm(arch=self.opts.arches)
q_old.filterm(arch=self.opts.arches)
if self.opts.compare_arch:
q_new.filterm(latest_per_arch=1)
q_old.filterm(latest_per_arch=1)
else:
q_new.filterm(latest=1)
q_old.filterm(latest=1)
q_new.apply()
q_old.apply()
self._report(self._repodiff(q_old, q_new))