X-Git-Url: https://review.fuel-infra.org/gitweb?a=blobdiff_plain;f=cirros-testvm%2Fsrc-cirros%2Fbuildroot-2015.05%2Fsupport%2Fscripts%2Fgraph-depends;fp=cirros-testvm%2Fsrc-cirros%2Fbuildroot-2015.05%2Fsupport%2Fscripts%2Fgraph-depends;h=c26e1e06dc5c10bef0318af1eeb7d30063915a03;hb=b0a0f15dfaa205161a7fcb20cf1b8cd4948c2ef3;hp=0000000000000000000000000000000000000000;hpb=c6ac3cd55ee2da956195eee393b0882105dfad4e;p=packages%2Ftrusty%2Fcirros-testvm.git diff --git a/cirros-testvm/src-cirros/buildroot-2015.05/support/scripts/graph-depends b/cirros-testvm/src-cirros/buildroot-2015.05/support/scripts/graph-depends new file mode 100755 index 0000000..c26e1e0 --- /dev/null +++ b/cirros-testvm/src-cirros/buildroot-2015.05/support/scripts/graph-depends @@ -0,0 +1,350 @@ +#!/usr/bin/python + +# Usage (the graphviz package must be installed in your distribution) +# ./support/scripts/graph-depends [-p package-name] > test.dot +# dot -Tpdf test.dot -o test.pdf +# +# With no arguments, graph-depends will draw a complete graph of +# dependencies for the current configuration. +# If '-p ' is specified, graph-depends will draw a graph +# of dependencies for the given package name. +# If '-d ' is specified, graph-depends will limit the depth of +# the dependency graph to 'depth' levels. +# +# Limitations +# +# * Some packages have dependencies that depend on the Buildroot +# configuration. For example, many packages have a dependency on +# openssl if openssl has been enabled. This tool will graph the +# dependencies as they are with the current Buildroot +# configuration. +# +# Copyright (C) 2010-2013 Thomas Petazzoni + +import sys +import subprocess +import argparse +from fnmatch import fnmatch + +# Modes of operation: +MODE_FULL = 1 # draw full dependency graph for all selected packages +MODE_PKG = 2 # draw dependency graph for a given package +mode = 0 + +# Limit drawing the dependency graph to this depth. 0 means 'no limit'. +max_depth = 0 + +# Whether to draw the transitive dependencies +transitive = True + +parser = argparse.ArgumentParser(description="Graph packages dependencies") +parser.add_argument("--package", '-p', metavar="PACKAGE", + help="Graph the dependencies of PACKAGE") +parser.add_argument("--depth", '-d', metavar="DEPTH", dest="depth", type=int, default=0, + help="Limit the dependency graph to DEPTH levels; 0 means no limit.") +parser.add_argument("--stop-on", "-s", metavar="PACKAGE", dest="stop_list", action="append", + help="Do not graph past this package (can be given multiple times)." \ + + " Can be a package name or a glob, or" \ + + " 'virtual' to stop on virtual packages.") +parser.add_argument("--exclude", "-x", metavar="PACKAGE", dest="exclude_list", action="append", + help="Like --stop-on, but do not add PACKAGE to the graph.") +parser.add_argument("--colours", "-c", metavar="COLOR_LIST", dest="colours", + default="lightblue,grey,gainsboro", + help="Comma-separated list of the three colours to use" \ + + " to draw the top-level package, the target" \ + + " packages, and the host packages, in this order." \ + + " Defaults to: 'lightblue,grey,gainsboro'") +parser.add_argument("--transitive", dest="transitive", action='store_true', + default=False) +parser.add_argument("--no-transitive", dest="transitive", action='store_false', + help="Draw (do not draw) transitive dependencies") +args = parser.parse_args() + +if args.package is None: + mode = MODE_FULL +else: + mode = MODE_PKG + rootpkg = args.package + +max_depth = args.depth + +if args.stop_list is None: + stop_list = [] +else: + stop_list = args.stop_list + +if args.exclude_list is None: + exclude_list = [] +else: + exclude_list = args.exclude_list + +transitive = args.transitive + +# Get the colours: we need exactly three colours, +# so no need not split more than 4 +# We'll let 'dot' validate the colours... +colours = args.colours.split(',',4) +if len(colours) != 3: + sys.stderr.write("Error: incorrect colour list '%s'\n" % args.colours) + sys.exit(1) +root_colour = colours[0] +target_colour = colours[1] +host_colour = colours[2] + +allpkgs = [] + +# Execute the "make -show-version" command to get the version of a given +# list of packages, and return the version formatted as a Python dictionary. +def get_version(pkgs): + sys.stderr.write("Getting version for %s\n" % pkgs) + cmd = ["make", "-s", "--no-print-directory" ] + for pkg in pkgs: + cmd.append("%s-show-version" % pkg) + p = subprocess.Popen(cmd, stdout=subprocess.PIPE, universal_newlines=True) + output = p.communicate()[0] + if p.returncode != 0: + sys.stderr.write("Error getting version %s\n" % pkgs) + sys.exit(1) + output = output.split("\n") + if len(output) != len(pkgs) + 1: + sys.stderr.write("Error getting version\n") + sys.exit(1) + version = {} + for i in range(0, len(pkgs)): + pkg = pkgs[i] + version[pkg] = output[i] + return version + +# Execute the "make show-targets" command to get the list of the main +# Buildroot PACKAGES and return it formatted as a Python list. This +# list is used as the starting point for full dependency graphs +def get_targets(): + sys.stderr.write("Getting targets\n") + cmd = ["make", "-s", "--no-print-directory", "show-targets"] + p = subprocess.Popen(cmd, stdout=subprocess.PIPE, universal_newlines=True) + output = p.communicate()[0].strip() + if p.returncode != 0: + return None + if output == '': + return [] + return output.split(' ') + +# Execute the "make -show-depends" command to get the list of +# dependencies of a given list of packages, and return the list of +# dependencies formatted as a Python dictionary. +def get_depends(pkgs): + sys.stderr.write("Getting dependencies for %s\n" % pkgs) + cmd = ["make", "-s", "--no-print-directory" ] + for pkg in pkgs: + cmd.append("%s-show-depends" % pkg) + p = subprocess.Popen(cmd, stdout=subprocess.PIPE, universal_newlines=True) + output = p.communicate()[0] + if p.returncode != 0: + sys.stderr.write("Error getting dependencies %s\n" % pkgs) + sys.exit(1) + output = output.split("\n") + if len(output) != len(pkgs) + 1: + sys.stderr.write("Error getting dependencies\n") + sys.exit(1) + deps = {} + for i in range(0, len(pkgs)): + pkg = pkgs[i] + pkg_deps = output[i].split(" ") + if pkg_deps == ['']: + deps[pkg] = [] + else: + deps[pkg] = pkg_deps + return deps + +# Recursive function that builds the tree of dependencies for a given +# list of packages. The dependencies are built in a list called +# 'dependencies', which contains tuples of the form (pkg1 -> +# pkg2_on_which_pkg1_depends, pkg3 -> pkg4_on_which_pkg3_depends) and +# the function finally returns this list. +def get_all_depends(pkgs): + dependencies = [] + + # Filter the packages for which we already have the dependencies + filtered_pkgs = [] + for pkg in pkgs: + if pkg in allpkgs: + continue + filtered_pkgs.append(pkg) + allpkgs.append(pkg) + + if len(filtered_pkgs) == 0: + return [] + + depends = get_depends(filtered_pkgs) + + deps = set() + for pkg in filtered_pkgs: + pkg_deps = depends[pkg] + + # This package has no dependency. + if pkg_deps == []: + continue + + # Add dependencies to the list of dependencies + for dep in pkg_deps: + dependencies.append((pkg, dep)) + deps.add(dep) + + if len(deps) != 0: + newdeps = get_all_depends(deps) + if newdeps is not None: + dependencies += newdeps + + return dependencies + +# The Graphviz "dot" utility doesn't like dashes in node names. So for +# node names, we strip all dashes. +def pkg_node_name(pkg): + return pkg.replace("-","") + +TARGET_EXCEPTIONS = [ + "target-finalize", + "target-post-image", +] + +# In full mode, start with the result of get_targets() to get the main +# targets and then use get_all_depends() for all targets +if mode == MODE_FULL: + targets = get_targets() + dependencies = [] + allpkgs.append('all') + filtered_targets = [] + for tg in targets: + # Skip uninteresting targets + if tg in TARGET_EXCEPTIONS: + continue + dependencies.append(('all', tg)) + filtered_targets.append(tg) + deps = get_all_depends(filtered_targets) + if deps is not None: + dependencies += deps + rootpkg = 'all' + +# In pkg mode, start directly with get_all_depends() on the requested +# package +elif mode == MODE_PKG: + dependencies = get_all_depends([rootpkg]) + +# Make the dependencies a dictionnary { 'pkg':[dep1, dep2, ...] } +dict_deps = {} +for dep in dependencies: + if dep[0] not in dict_deps: + dict_deps[dep[0]] = [] + dict_deps[dep[0]].append(dep[1]) + +# This function return True if pkg is a dependency (direct or +# transitive) of pkg2, dependencies being listed in the deps +# dictionary. Returns False otherwise. +def is_dep(pkg,pkg2,deps): + if pkg2 in deps: + for p in deps[pkg2]: + if pkg == p: + return True + if is_dep(pkg,p,deps): + return True + return False + +# This function eliminates transitive dependencies; for example, given +# these dependency chain: A->{B,C} and B->{C}, the A->{C} dependency is +# already covered by B->{C}, so C is a transitive dependency of A, via B. +# The functions does: +# - for each dependency d[i] of the package pkg +# - if d[i] is a dependency of any of the other dependencies d[j] +# - do not keep d[i] +# - otherwise keep d[i] +def remove_transitive_deps(pkg,deps): + d = deps[pkg] + new_d = [] + for i in range(len(d)): + keep_me = True + for j in range(len(d)): + if j==i: + continue + if is_dep(d[i],d[j],deps): + keep_me = False + if keep_me: + new_d.append(d[i]) + return new_d + +# This function removes the dependency on the 'toolchain' package +def remove_toolchain_deps(pkg,deps): + return [p for p in deps[pkg] if not p == 'toolchain'] + +# This functions trims down the dependency list of all packages. +# It applies in sequence all the dependency-elimination methods. +def remove_extra_deps(deps): + for pkg in list(deps.keys()): + if not pkg == 'all': + deps[pkg] = remove_toolchain_deps(pkg,deps) + for pkg in list(deps.keys()): + if not transitive or pkg == 'all': + deps[pkg] = remove_transitive_deps(pkg,deps) + return deps + +dict_deps = remove_extra_deps(dict_deps) +dict_version = get_version([pkg for pkg in allpkgs + if pkg != "all" and not pkg.startswith("root")]) + +# Print the attributes of a node: label and fill-color +def print_attrs(pkg): + name = pkg_node_name(pkg) + if pkg == 'all': + label = 'ALL' + else: + label = pkg + if pkg == 'all' or (mode == MODE_PKG and pkg == rootpkg): + color = root_colour + else: + if pkg.startswith('host') \ + or pkg.startswith('toolchain') \ + or pkg.startswith('rootfs'): + color = host_colour + else: + color = target_colour + version = dict_version.get(pkg) + if version == "virtual": + print("%s [label = <%s>]" % (name, label)) + else: + print("%s [label = \"%s\"]" % (name, label)) + print("%s [color=%s,style=filled]" % (name, color)) + +# Print the dependency graph of a package +def print_pkg_deps(depth, pkg): + if pkg in done_deps: + return + done_deps.append(pkg) + print_attrs(pkg) + if pkg not in dict_deps: + return + for p in stop_list: + if fnmatch(pkg, p): + return + if dict_version.get(pkg) == "virtual" and "virtual" in stop_list: + return + if max_depth == 0 or depth < max_depth: + for d in dict_deps[pkg]: + add = True + for p in exclude_list: + if fnmatch(d,p): + add = False + break + if dict_version.get(d) == "virtual" \ + and "virtual" in exclude_list: + add = False + break + if add: + print("%s -> %s" % (pkg_node_name(pkg), pkg_node_name(d))) + print_pkg_deps(depth+1, d) + +# Start printing the graph data +print("digraph G {") + +done_deps = [] +print_pkg_deps(0, rootpkg) + +print("}")