| #!/usr/bin/env python |
| # Copyright 2013 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Dumps a graph of allowed and disallowed inter-module dependencies described |
| by the DEPS files in the source tree. Supports DOT and PNG as the output format. |
| |
| Enables filtering and differential highlighting of parts of the graph based on |
| the specified criteria. This allows for a much easier visual analysis of the |
| dependencies, including answering questions such as "if a new source must |
| depend on modules A, B, and C, what valid options among the existing modules |
| are there to put it in." |
| |
| See README.md for a detailed description of the DEPS format. |
| """ |
| |
| import os |
| import optparse |
| import pipes |
| import re |
| import sys |
| |
| from builddeps import DepsBuilder |
| from rules import Rule |
| |
| |
| class DepsGrapher(DepsBuilder): |
| """Parses include_rules from DEPS files and outputs a DOT graph of the |
| allowed and disallowed dependencies between directories and specific file |
| regexps. Can generate only a subgraph of the whole dependency graph |
| corresponding to the provided inclusion and exclusion regexp filters. |
| Also can highlight fanins and/or fanouts of certain nodes matching the |
| provided regexp patterns. |
| """ |
| |
| def __init__(self, |
| base_directory, |
| extra_repos, |
| verbose, |
| being_tested, |
| ignore_temp_rules, |
| ignore_specific_rules, |
| hide_disallowed_deps, |
| out_file, |
| out_format, |
| layout_engine, |
| unflatten_graph, |
| incl, |
| excl, |
| hilite_fanins, |
| hilite_fanouts): |
| """Creates a new DepsGrapher. |
| |
| Args: |
| base_directory: OS-compatible path to root of checkout, e.g. C:\chr\src. |
| verbose: Set to true for debug output. |
| being_tested: Set to true to ignore the DEPS file at tools/graphdeps/DEPS. |
| ignore_temp_rules: Ignore rules that start with Rule.TEMP_ALLOW ("!"). |
| ignore_specific_rules: Ignore rules from specific_include_rules sections. |
| hide_disallowed_deps: Hide disallowed dependencies from the output graph. |
| out_file: Output file name. |
| out_format: Output format (anything GraphViz dot's -T option supports). |
| layout_engine: Layout engine for formats other than 'dot' |
| (anything that GraphViz dot's -K option supports). |
| unflatten_graph: Try to reformat the output graph so it is narrower and |
| taller. Helps fight overly flat and wide graphs, but |
| sometimes produces a worse result. |
| incl: Include only nodes matching this regexp; such nodes' fanin/fanout |
| is also included. |
| excl: Exclude nodes matching this regexp; such nodes' fanin/fanout is |
| processed independently. |
| hilite_fanins: Highlight fanins of nodes matching this regexp with a |
| different edge and node color. |
| hilite_fanouts: Highlight fanouts of nodes matching this regexp with a |
| different edge and node color. |
| """ |
| DepsBuilder.__init__( |
| self, |
| base_directory, |
| extra_repos, |
| verbose, |
| being_tested, |
| ignore_temp_rules, |
| ignore_specific_rules) |
| |
| self.ignore_temp_rules = ignore_temp_rules |
| self.ignore_specific_rules = ignore_specific_rules |
| self.hide_disallowed_deps = hide_disallowed_deps |
| self.out_file = out_file |
| self.out_format = out_format |
| self.layout_engine = layout_engine |
| self.unflatten_graph = unflatten_graph |
| self.incl = incl |
| self.excl = excl |
| self.hilite_fanins = hilite_fanins |
| self.hilite_fanouts = hilite_fanouts |
| |
| self.deps = set() |
| |
| def DumpDependencies(self): |
| """ Builds a dependency rule table and dumps the corresponding dependency |
| graph to all requested formats.""" |
| self._BuildDepsGraph() |
| self._DumpDependencies() |
| |
| def _BuildDepsGraph(self): |
| """Recursively traverses the source tree starting at the specified directory |
| and builds a dependency graph representation in self.deps.""" |
| for (rules, _) in self.GetAllRulesAndFiles(): |
| deps = rules.AsDependencyTuples( |
| include_general_rules=True, |
| include_specific_rules=not self.ignore_specific_rules) |
| self.deps.update(deps) |
| |
| def _DumpDependencies(self): |
| """Dumps the built dependency graph to the specified file with specified |
| format.""" |
| if self.out_format == 'dot' and not self.layout_engine: |
| if self.unflatten_graph: |
| pipe = pipes.Template() |
| pipe.append('unflatten -l 2 -c 3', '--') |
| out = pipe.open(self.out_file, 'w') |
| else: |
| out = open(self.out_file, 'w') |
| else: |
| pipe = pipes.Template() |
| if self.unflatten_graph: |
| pipe.append('unflatten -l 2 -c 3', '--') |
| dot_cmd = 'dot -T' + self.out_format |
| if self.layout_engine: |
| dot_cmd += ' -K' + self.layout_engine |
| pipe.append(dot_cmd, '--') |
| out = pipe.open(self.out_file, 'w') |
| |
| self._DumpDependenciesImpl(self.deps, out) |
| out.close() |
| |
| def _DumpDependenciesImpl(self, deps, out): |
| """Computes nodes' and edges' properties for the dependency graph |deps| and |
| carries out the actual dumping to a file/pipe |out|.""" |
| deps_graph = dict() |
| deps_srcs = set() |
| |
| # Pre-initialize the graph with src->(dst, allow) pairs. |
| for (allow, src, dst) in deps: |
| if allow == Rule.TEMP_ALLOW and self.ignore_temp_rules: |
| continue |
| |
| deps_srcs.add(src) |
| if src not in deps_graph: |
| deps_graph[src] = [] |
| deps_graph[src].append((dst, allow)) |
| |
| # Add all hierarchical parents too, in case some of them don't have their |
| # own DEPS, and therefore are missing from the list of rules. Those will |
| # be recursively populated with their parents' rules in the next block. |
| parent_src = os.path.dirname(src) |
| while parent_src: |
| if parent_src not in deps_graph: |
| deps_graph[parent_src] = [] |
| parent_src = os.path.dirname(parent_src) |
| |
| # For every node, propagate its rules down to all its children. |
| deps_srcs = list(deps_srcs) |
| deps_srcs.sort() |
| for src in deps_srcs: |
| parent_src = os.path.dirname(src) |
| if parent_src: |
| # We presort the list, so parents are guaranteed to precede children. |
| assert parent_src in deps_graph,\ |
| "src: %s, parent_src: %s" % (src, parent_src) |
| for (dst, allow) in deps_graph[parent_src]: |
| # Check that this node does not explicitly override a rule from the |
| # parent that we're about to add. |
| if ((dst, Rule.ALLOW) not in deps_graph[src]) and \ |
| ((dst, Rule.TEMP_ALLOW) not in deps_graph[src]) and \ |
| ((dst, Rule.DISALLOW) not in deps_graph[src]): |
| deps_graph[src].append((dst, allow)) |
| |
| node_props = {} |
| edges = [] |
| |
| # 1) Populate a list of edge specifications in DOT format; |
| # 2) Populate a list of computed raw node attributes to be output as node |
| # specifications in DOT format later on. |
| # Edges and nodes are emphasized with color and line/border weight depending |
| # on how many of incl/excl/hilite_fanins/hilite_fanouts filters they hit, |
| # and in what way. |
| for src in deps_graph.keys(): |
| for (dst, allow) in deps_graph[src]: |
| if allow == Rule.DISALLOW and self.hide_disallowed_deps: |
| continue |
| |
| if allow == Rule.ALLOW and src == dst: |
| continue |
| |
| edge_spec = "%s->%s" % (src, dst) |
| if not re.search(self.incl, edge_spec) or \ |
| re.search(self.excl, edge_spec): |
| continue |
| |
| if src not in node_props: |
| node_props[src] = {'hilite': None, 'degree': 0} |
| if dst not in node_props: |
| node_props[dst] = {'hilite': None, 'degree': 0} |
| |
| edge_weight = 1 |
| |
| if self.hilite_fanouts and re.search(self.hilite_fanouts, src): |
| node_props[src]['hilite'] = 'lightgreen' |
| node_props[dst]['hilite'] = 'lightblue' |
| node_props[dst]['degree'] += 1 |
| edge_weight += 1 |
| |
| if self.hilite_fanins and re.search(self.hilite_fanins, dst): |
| node_props[src]['hilite'] = 'lightblue' |
| node_props[dst]['hilite'] = 'lightgreen' |
| node_props[src]['degree'] += 1 |
| edge_weight += 1 |
| |
| if allow == Rule.ALLOW: |
| edge_color = (edge_weight > 1) and 'blue' or 'green' |
| edge_style = 'solid' |
| elif allow == Rule.TEMP_ALLOW: |
| edge_color = (edge_weight > 1) and 'blue' or 'green' |
| edge_style = 'dashed' |
| else: |
| edge_color = 'red' |
| edge_style = 'dashed' |
| edges.append(' "%s" -> "%s" [style=%s,color=%s,penwidth=%d];' % \ |
| (src, dst, edge_style, edge_color, edge_weight)) |
| |
| # Reformat the computed raw node attributes into a final DOT representation. |
| nodes = [] |
| for (node, attrs) in node_props.items(): |
| attr_strs = [] |
| if attrs['hilite']: |
| attr_strs.append('style=filled,fillcolor=%s' % attrs['hilite']) |
| attr_strs.append('penwidth=%d' % (attrs['degree'] or 1)) |
| nodes.append(' "%s" [%s];' % (node, ','.join(attr_strs))) |
| |
| # Output nodes and edges to |out| (can be a file or a pipe). |
| edges.sort() |
| nodes.sort() |
| out.write('digraph DEPS {\n' |
| ' fontsize=8;\n') |
| out.write('\n'.join(nodes)) |
| out.write('\n\n') |
| out.write('\n'.join(edges)) |
| out.write('\n}\n') |
| out.close() |
| |
| |
| def PrintUsage(): |
| print("""Usage: python graphdeps.py [--root <root>] |
| |
| --root ROOT Specifies the repository root. This defaults to "../../.." |
| relative to the script file. This will be correct given the |
| normal location of the script in "<root>/tools/graphdeps". |
| |
| --(others) There are a few lesser-used options; run with --help to show them. |
| |
| Examples: |
| Dump the whole dependency graph: |
| graphdeps.py |
| Find a suitable place for a new source that must depend on /apps and |
| /content/browser/renderer_host. Limit potential candidates to /apps, |
| /chrome/browser and content/browser, and descendants of those three. |
| Generate both DOT and PNG output. The output will highlight the fanins |
| of /apps and /content/browser/renderer_host. Overlapping nodes in both fanins |
| will be emphasized by a thicker border. Those nodes are the ones that are |
| allowed to depend on both targets, therefore they are all legal candidates |
| to place the new source in: |
| graphdeps.py \ |
| --root=./src \ |
| --out=./DEPS.svg \ |
| --format=svg \ |
| --incl='^(apps|chrome/browser|content/browser)->.*' \ |
| --excl='.*->third_party' \ |
| --fanin='^(apps|content/browser/renderer_host)$' \ |
| --ignore-specific-rules \ |
| --ignore-temp-rules""") |
| |
| |
| def main(): |
| option_parser = optparse.OptionParser() |
| option_parser.add_option( |
| "", "--root", |
| default="", dest="base_directory", |
| help="Specifies the repository root. This defaults " |
| "to '../../..' relative to the script file, which " |
| "will normally be the repository root.") |
| option_parser.add_option( |
| '', '--extra-repos', |
| action='append', dest='extra_repos', default=[], |
| help='Specifies extra repositories relative to root repository.') |
| option_parser.add_option( |
| "-f", "--format", |
| dest="out_format", default="dot", |
| help="Output file format. " |
| "Can be anything that GraphViz dot's -T option supports. " |
| "The most useful ones are: dot (text), svg (image), pdf (image)." |
| "NOTES: dotty has a known problem with fonts when displaying DOT " |
| "files on Ubuntu - if labels are unreadable, try other formats.") |
| option_parser.add_option( |
| "-o", "--out", |
| dest="out_file", default="DEPS", |
| help="Output file name. If the name does not end in an extension " |
| "matching the output format, that extension is automatically " |
| "appended.") |
| option_parser.add_option( |
| "-l", "--layout-engine", |
| dest="layout_engine", default="", |
| help="Layout rendering engine. " |
| "Can be anything that GraphViz dot's -K option supports. " |
| "The most useful are in decreasing order: dot, fdp, circo, osage. " |
| "NOTE: '-f dot' and '-f dot -l dot' are different: the former " |
| "will dump a raw DOT graph and stop; the latter will further " |
| "filter it through 'dot -Tdot -Kdot' layout engine.") |
| option_parser.add_option( |
| "-i", "--incl", |
| default="^.*$", dest="incl", |
| help="Include only edges of the graph that match the specified regexp. " |
| "The regexp is applied to edges of the graph formatted as " |
| "'source_node->target_node', where the '->' part is vebatim. " |
| "Therefore, a reliable regexp should look like " |
| "'^(chrome|chrome/browser|chrome/common)->content/public/browser$' " |
| "or similar, with both source and target node regexps present, " |
| "explicit ^ and $, and otherwise being as specific as possible.") |
| option_parser.add_option( |
| "-e", "--excl", |
| default="^$", dest="excl", |
| help="Exclude dependent nodes that match the specified regexp. " |
| "See --incl for details on the format.") |
| option_parser.add_option( |
| "", "--fanin", |
| default="", dest="hilite_fanins", |
| help="Highlight fanins of nodes matching the specified regexp.") |
| option_parser.add_option( |
| "", "--fanout", |
| default="", dest="hilite_fanouts", |
| help="Highlight fanouts of nodes matching the specified regexp.") |
| option_parser.add_option( |
| "", "--ignore-temp-rules", |
| action="store_true", dest="ignore_temp_rules", default=False, |
| help="Ignore !-prefixed (temporary) rules in DEPS files.") |
| option_parser.add_option( |
| "", "--ignore-specific-rules", |
| action="store_true", dest="ignore_specific_rules", default=False, |
| help="Ignore specific_include_rules section of DEPS files.") |
| option_parser.add_option( |
| "", "--hide-disallowed-deps", |
| action="store_true", dest="hide_disallowed_deps", default=False, |
| help="Hide disallowed dependencies in the output graph.") |
| option_parser.add_option( |
| "", "--unflatten", |
| action="store_true", dest="unflatten_graph", default=False, |
| help="Try to reformat the output graph so it is narrower and taller. " |
| "Helps fight overly flat and wide graphs, but sometimes produces " |
| "inferior results.") |
| option_parser.add_option( |
| "-v", "--verbose", |
| action="store_true", default=False, |
| help="Print debug logging") |
| options, args = option_parser.parse_args() |
| |
| if not options.out_file.endswith(options.out_format): |
| options.out_file += '.' + options.out_format |
| |
| deps_grapher = DepsGrapher( |
| base_directory=options.base_directory, |
| extra_repos=options.extra_repos, |
| verbose=options.verbose, |
| being_tested=False, |
| |
| ignore_temp_rules=options.ignore_temp_rules, |
| ignore_specific_rules=options.ignore_specific_rules, |
| hide_disallowed_deps=options.hide_disallowed_deps, |
| |
| out_file=options.out_file, |
| out_format=options.out_format, |
| layout_engine=options.layout_engine, |
| unflatten_graph=options.unflatten_graph, |
| |
| incl=options.incl, |
| excl=options.excl, |
| hilite_fanins=options.hilite_fanins, |
| hilite_fanouts=options.hilite_fanouts) |
| |
| if len(args) > 0: |
| PrintUsage() |
| return 1 |
| |
| print('Using base directory: ', deps_grapher.base_directory) |
| print('include nodes : ', options.incl) |
| print('exclude nodes : ', options.excl) |
| print('highlight fanins of : ', options.hilite_fanins) |
| print('highlight fanouts of: ', options.hilite_fanouts) |
| |
| deps_grapher.DumpDependencies() |
| return 0 |
| |
| |
| if '__main__' == __name__: |
| sys.exit(main()) |
