Use a response file for gn refs when running 'analyze' on gn bots.

tools/mb/mb.py

 #!/usr/bin/env python
 # Copyright 2015 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """MB - the Meta-Build wrapper around GYP and GN
 
 MB is a wrapper script for GYP and GN that can be used to generate build files
 for sets of canned configurations and analyze them.
 """
 
 from __future__ import print_function
 
 import argparse
 import ast
 import json
 import os
 import pipes
 import shlex
 import shutil
 import sys
 import subprocess
+import tempfile
 
 
 def main(args):
   mbw = MetaBuildWrapper()
   mbw.ParseArgs(args)
   return mbw.args.func()
 
 
 class MetaBuildWrapper(object):
   def __init__(self):
@@ skipping 375 matching lines @@
       self.Print()
 
     output_path = self.args.output_path[0]
 
     # Bail out early if a GN file was modified, since 'gn refs' won't know
     # what to do about it.
     if any(f.endswith('.gn') or f.endswith('.gni') for f in inp['files']):
       self.WriteJSON({'status': 'Found dependency (all)'}, output_path)
       return 0
 
-    # TODO: Because of the --type=executable filter below, we don't detect
-    # when files will cause 'all' or 'gn_all' or similar targets to be
-    # dirty. We need to figure out how to handle that properly, but for
-    # now we can just bail out early.
-    if 'gn_all' in inp['targets'] or 'all' in inp['targets']:
+    # Bail out early if 'all' was asked for, since 'gn refs' won't recognize it.
+    if 'all' in inp['targets']:
       self.WriteJSON({'status': 'Found dependency (all)'}, output_path)
       return 0
 
-    all_needed_targets = set()
     ret = 0
-    for f in inp['files']:
+    response_file = self.TempFile()
+    response_file.write('\n'.join(inp['files']) + '\n')
+    response_file.close()
+
+    matching_targets = []
+    try:
       cmd = self.GNCmd('refs', self.args.path[0]) + [
-             '//' + f, '--type=executable', '--all', '--as=output']
+          '@%s' % response_file.name,
+          '--type=executable', '--all', '--as=output'
+      ]
       ret, out, _ = self.Run(cmd)
       if ret and not 'The input matches no targets' in out:
         self.WriteFailureAndRaise('gn refs returned %d: %s' % (ret, out),
                                   output_path)
+      build_dir = self.ToSrcRelPath(self.args.path[0]) + os.sep
+      for output in out.splitlines():
+        build_output = output.replace(build_dir, '')
+        if build_output in inp['targets']:
+          matching_targets.append(build_output)
+    finally:
+      self.RemoveFile(response_file.name)
 
-      rpath = self.ToSrcRelPath(self.args.path[0]) + os.sep
-      needed_targets = [t.replace(rpath, '') for t in out.splitlines()]
-      needed_targets = [nt for nt in needed_targets if nt in inp['targets']]
-      all_needed_targets.update(set(needed_targets))
-
-    if all_needed_targets:
+    if matching_targets:
       # TODO: it could be that a target X might depend on a target Y
       # and both would be listed in the input, but we would only need
       # to specify target X as a build_target (whereas both X and Y are
       # targets). I'm not sure if that optimization is generally worth it.
-      self.WriteJSON({'targets': sorted(all_needed_targets),
-                      'build_targets': sorted(all_needed_targets),
+      self.WriteJSON({'targets': sorted(matching_targets),
+                      'build_targets': sorted(matching_targets),
                       'status': 'Found dependency'}, output_path)
     else:
       self.WriteJSON({'targets': [],
                       'build_targets': [],
                       'status': 'No dependency'}, output_path)
 
     if not ret and self.args.verbose:
       outp = json.loads(self.ReadFile(output_path))
       self.Print()
       self.Print('analyze output:')
@@ skipping 71 matching lines @@
 
   def Exists(self, path):
     # This function largely exists so it can be overridden for testing.
     return os.path.exists(path)
 
   def ReadFile(self, path):
     # This function largely exists so it can be overriden for testing.
     with open(path) as fp:
       return fp.read()
 
+  def RemoveFile(self, path):
+    # This function largely exists so it can be overriden for testing.
+    os.remove(path)
+
+  def TempFile(self, mode='w'):
+    # This function largely exists so it can be overriden for testing.
+    return tempfile.NamedTemporaryFile(mode=mode, delete=False)
+
   def WriteFile(self, path, contents):
     # This function largely exists so it can be overriden for testing.
     with open(path, 'w') as fp:
       return fp.write(contents)
 
+
 class MBErr(Exception):
   pass
 
 
 if __name__ == '__main__':
   try:
     sys.exit(main(sys.argv[1:]))
   except MBErr as e:
     print(e)
     sys.exit(1)
   except KeyboardInterrupt:
     print("interrupted, exiting", stream=sys.stderr)
     sys.exit(130)