support/scripts/graph-depends - buildroot - Git at Google

 #!/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("}")
	#!/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("}")