Rework gclient 'recurse' command to use a WorkQueue.

gclient.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """Meta checkout manager supporting both Subversion and GIT.
 
 Files
   .gclient      : Current client configuration, written by 'config' command.
                   Format is a Python script defining 'solutions', a list whose
@@ skipping 507 matching lines @@
   # pylint: disable=W0221
   def run(self, revision_overrides, command, args, work_queue, options):
     """Runs |command| then parse the DEPS file."""
     logging.info('Dependency(%s).run()' % self.name)
     assert self._file_list == []
     if not self.should_process:
       return
     # When running runhooks, there's no need to consult the SCM.
     # All known hooks are expected to run unconditionally regardless of working
     # copy state, so skip the SCM status check.
-    run_scm = command not in ('runhooks', None)
+    run_scm = command not in ('runhooks', 'recurse', None)

[davidbarr, 2012/03/02 03:21:55]

It felt a bit too tricky to implicitly rely on this value.

     parsed_url = self.LateOverride(self.url)
     file_list = []
     if run_scm and parsed_url:
       if isinstance(parsed_url, self.FileImpl):
         # Special support for single-file checkout.
         if not command in (None, 'cleanup', 'diff', 'pack', 'status'):
           # Sadly, pylint doesn't realize that parsed_url is of FileImpl.
           # pylint: disable=E1103
           options.revision = parsed_url.GetRevision()
           scm = gclient_scm.SVNWrapper(parsed_url.GetPath(),
@@ skipping 19 matching lines @@
       for i in range(len(file_list)):
         # It depends on the command being executed (like runhooks vs sync).
         if not os.path.isabs(file_list[i]):
           continue
         prefix = os.path.commonprefix(
             [self.root.root_dir.lower(), file_list[i].lower()])
         file_list[i] = file_list[i][len(prefix):]
         # Strip any leading path separators.
         while file_list[i].startswith(('\\', '/')):
           file_list[i] = file_list[i][1:]
+    elif command is 'recurse':
+      if not isinstance(parsed_url, self.FileImpl):
+        # Skip file only checkout.
+        scm = gclient_scm.GetScmName(parsed_url)
+        if not options.scm or scm in options.scm:
+          cwd = os.path.normpath(os.path.join(self.root.root_dir, self.name))
+          # Pass in the SCM type as an env variable
+          env = os.environ.copy()
+          if scm:
+            env['GCLIENT_SCM'] = scm
+          if parsed_url:
+            env['GCLIENT_URL'] = parsed_url
+          if os.path.isdir(cwd):
+            gclient_utils.CheckCallAndFilterAndHeader(args, cwd=cwd, env=env)
+          else:
+            print >> sys.stderr, 'Skipped missing %s' % cwd
 
     # Always parse the DEPS file.
     self.ParseDepsFile()
 
     self._run_is_done(file_list, parsed_url)
 
     if self.recursion_limit:
       # Parse the dependencies of this dependency.
       for s in self.dependencies:
         work_queue.enqueue(s)
@@ skipping 380 matching lines @@
 
   def RunOnDeps(self, command, args):
     """Runs a command on each dependency in a client and its dependencies.
 
     Args:
       command: The command to use (e.g., 'status' or 'diff')
       args: list of str - extra arguments to add to the command line.
     """
     if not self.dependencies:
       raise gclient_utils.Error('No solution specified')
-    revision_overrides = self._EnforceRevisions()
+    revision_overrides = {}
+    if command is not 'recurse':
+      revision_overrides = self._EnforceRevisions()

[davidbarr, 2012/03/02 03:21:55]

Is _EnforceRevisions() necessary in the 'recurse' case? It adds about 6 seconds
to the startup time.

[M-A Ruel, 2012/03/02 14:25:30]

Just add a comment that it's not strictly necessary in that case and that it's
an optimisation to skip that.

     pm = None
     # Disable progress for non-tty stdout.
-    if (command in ('update', 'revert') and sys.stdout.isatty() and not
-        self._options.verbose):
-      pm = Progress('Syncing projects', 1)
+    if (sys.stdout.isatty() and not self._options.verbose):
+      if command in ('update', 'revert'):
+        pm = Progress('Syncing projects', 1)
+      elif command is 'recurse':
+        pm = Progress(' '.join(args), 1)
     work_queue = gclient_utils.ExecutionQueue(self._options.jobs, pm)
     for s in self.dependencies:
       work_queue.enqueue(s)
     work_queue.flush(revision_overrides, command, args, options=self._options)
 
     # Once all the dependencies have been processed, it's now safe to run the
     # hooks.
     if not self._options.nohooks:
       self.RunHooksRecursively(self._options)
 
@@ skipping 140 matching lines @@
 @attr('usage', '[command] [args ...]')
 def CMDrecurse(parser, args):
   """Operates on all the entries.
 
   Runs a shell command on all entries.
   """
   # Stop parsing at the first non-arg so that these go through to the command
   parser.disable_interspersed_args()
   parser.add_option('-s', '--scm', action='append', default=[],
                     help='choose scm types to operate upon')
-  parser.remove_option('--jobs')
   options, args = parser.parse_args(args)
   if not args:
     print >> sys.stderr, 'Need to supply a command!'
     return 1
   root_and_entries = gclient_utils.GetGClientRootAndEntries()
   if not root_and_entries:
     print >> sys.stderr, (
         'You need to run gclient sync at least once to use \'recurse\'.\n'
         'This is because .gclient_entries needs to exist and be up to date.')
     return 1
-  root, entries = root_and_entries
+
+  # Normalize options.scm to a set()
   scm_set = set()
   for scm in options.scm:
     scm_set.update(scm.split(','))
+  options.scm = scm_set
 
-  # Pass in the SCM type as an env variable
-  env = os.environ.copy()
-
-  for path, url in entries.iteritems():
-    scm = gclient_scm.GetScmName(url)
-    if scm_set and scm not in scm_set:
-      continue
-    cwd = os.path.normpath(os.path.join(root, path))
-    if scm:
-      env['GCLIENT_SCM'] = scm
-    if url:
-      env['GCLIENT_URL'] = url
-    if os.path.isdir(cwd):
-      subprocess2.call(args, cwd=cwd, env=env)
-    else:
-      print >> sys.stderr, 'Skipped missing %s' % cwd
-  return 0
+  options.nohooks = True
+  client = GClient.LoadCurrentConfig(options)
+  return client.RunOnDeps('recurse', args)
 
 
 @attr('usage', '[args ...]')
 def CMDfetch(parser, args):
   """Fetches upstream commits for all modules.
 
 Completely git-specific. Simply runs 'git fetch [args ...]' for each module.
 """
-  (_, args) = parser.parse_args(args)
-  args = ['-s', 'git', 'git', 'fetch'] + args
+  (options, args) = parser.parse_args(args)
+  args = ['-j%d' % options.jobs, '-s', 'git', 'git', 'fetch'] + args
   return CMDrecurse(parser, args)
 
 
 @attr('usage', '[url] [safesync url]')
 def CMDconfig(parser, args):
   """Create a .gclient file in the current directory.
 
 This specifies the configuration for further commands. After update/sync,
 top-level DEPS files in each module are read to determine dependent
 modules to operate on as well. If optional [url] parameter is
@@ skipping 362 matching lines @@
   except (gclient_utils.Error, subprocess2.CalledProcessError), e:
     print >> sys.stderr, 'Error: %s' % str(e)
     return 1
 
 
 if '__main__' == __name__:
   fix_encoding.fix_encoding()
   sys.exit(Main(sys.argv[1:]))
 
 # vim: ts=2:sw=2:tw=80:et: