8a58e0238e
For clarity, this commit renames the TARGETS variable to the more meaningful PACKAGES variable. Indeed, only packages (handled by one of the package infrastructures) should be listed in this variable, and not other random non-package targets. Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com> Reviewed-by: "Yann E. MORIN" <yann.morin.1998@free.fr>
351 lines
12 KiB
Python
Executable File
351 lines
12 KiB
Python
Executable File
#!/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 <package-name>' is specified, graph-depends will draw a graph
|
|
# of dependencies for the given package name.
|
|
# If '-d <depth>' 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 <thomas.petazzoni@free-electrons.com>
|
|
|
|
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 <pkg>-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 <pkg>-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 = <<I>%s</I>>]" % (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("}")
|