#!/usr/bin/python3 # # Copyright (C) 2011, Stefano Rivera # # Permission to use, copy, modify, and/or distribute this software for any # purpose with or without fee is hereby granted, provided that the above # copyright notice and this permission notice appear in all copies. # # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. import argparse import sys from distro_info import DistroDataOutdated from ubuntutools.misc import (system_distribution, vendor_to_distroinfo, codename_to_distribution) from ubuntutools.rdepends import query_rdepends, RDependsException from ubuntutools import getLogger Logger = getLogger(__name__) DEFAULT_MAX_DEPTH = 10 # We want avoid any infinite loop... def main(): system_distro_info = vendor_to_distroinfo(system_distribution())() try: default_release = system_distro_info.devel() except DistroDataOutdated as e: Logger.warning(e) default_release = 'unstable' description = ("List reverse-dependencies of package. " "If the package name is prefixed with src: then the " "reverse-dependencies of all the binary packages that " "the specified source package builds will be listed.") parser = argparse.ArgumentParser(description=description) parser.add_argument('-r', '--release', default=default_release, help='Query dependencies in RELEASE. ' 'Default: %s' % default_release) parser.add_argument('-R', '--without-recommends', action='store_false', dest='recommends', help='Only consider Depends relationships, ' 'not Recommends') parser.add_argument('-s', '--with-suggests', action='store_true', help='Also consider Suggests relationships') parser.add_argument('-b', '--build-depends', action='store_true', help='Query build dependencies (synonym for --arch=source)') parser.add_argument('-a', '--arch', default='any', help='Query dependencies in ARCH. Default: any') parser.add_argument('-c', '--component', action='append', help='Only consider reverse-dependencies in COMPONENT. ' 'Can be specified multiple times. Default: all') parser.add_argument('-l', '--list', action='store_true', help='Display a simple, machine-readable list') parser.add_argument('-u', '--service-url', metavar='URL', dest='server', default=None, help='Reverse Dependencies webservice URL. ' 'Default: UbuntuWire') parser.add_argument('-x', '--recursive', action='store_true', help='Consider to find reverse dependencies recursively.') parser.add_argument('-d', '--recursive-depth', type=int, default=DEFAULT_MAX_DEPTH, help='If recusive, you can specify the depth.') parser.add_argument('package') options = parser.parse_args() opts = {} if options.server is not None: opts['server'] = options.server # Convert unstable/testing aliases to codenames: distribution = codename_to_distribution(options.release) if not distribution: parser.error('Unknown release codename %s' % options.release) distro_info = vendor_to_distroinfo(distribution)() try: options.release = distro_info.codename(options.release, default=options.release) except DistroDataOutdated: # We already logged a warning pass if options.build_depends: options.arch = 'source' if options.arch == 'source': fields = [ 'Reverse-Build-Depends', 'Reverse-Build-Depends-Indep', 'Reverse-Build-Depends-Arch', 'Reverse-Testsuite-Triggers', ] else: fields = ['Reverse-Depends'] if options.recommends: fields.append('Reverse-Recommends') if options.with_suggests: fields.append('Reverse-Suggests') def build_results(package, result, fields, component, recursive): try: data = query_rdepends(package, options.release, options.arch, **opts) except RDependsException as e: Logger.error(str(e)) sys.exit(1) if not data: return if fields: data = {k: v for k, v in data.items() if k in fields} if component: data = {k: [rdep for rdep in v if rdep['Component'] in component] for k, v in data.items()} data = {k: v for k, v in data.items() if v} result[package] = data if recursive > 0: for rdeps in result[package].values(): for rdep in rdeps: build_results( rdep['Package'], result, fields, component, recursive - 1) result = {} build_results( options.package, result, fields, options.component, options.recursive and options.recursive_depth or 0) if options.list: display_consise(result) else: display_verbose(options.package, result) def display_verbose(package, values): if not values: Logger.info("No reverse dependencies found") return def log_field(field): Logger.info(field) Logger.info('=' * len(field)) def log_package(values, package, arch, dependency, offset=0): line = ' ' * offset + '* %s' % package if all_archs and set(arch) != all_archs: line += ' [%s]' % ' '.join(sorted(arch)) if dependency: if len(line) < 30: line += ' ' * (30 - len(line)) line += ' (for %s)' % dependency Logger.info(line) data = values.get(package) if data: offset = offset + 1 for rdeps in data.values(): for rdep in rdeps: log_package(values, rdep['Package'], rdep.get('Architectures', all_archs), rdep.get('Dependency'), offset) all_archs = set() # This isn't accurate, but we make up for it by displaying what we found for data in values.values(): for rdeps in data.values(): for rdep in rdeps: if 'Architectures' in rdep: all_archs.update(rdep['Architectures']) for field, rdeps in values[package].items(): Logger.info(field) rdeps.sort(key=lambda x: x['Package']) for rdep in rdeps: log_package(values, rdep['Package'], rdep.get('Architectures', all_archs), rdep.get('Dependency')) Logger.info("") if all_archs: Logger.info("Packages without architectures listed are " "reverse-dependencies in: %s" % ', '.join(sorted(list(all_archs)))) def display_consise(values): result = set() for data in values.values(): for rdeps in data.values(): for rdep in rdeps: result.add(rdep['Package']) Logger.info('\n'.join(sorted(list(result)))) if __name__ == '__main__': main()