Add support in gclient for pre-DEPS hooks

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
 #                   entries each are maps binding the strings "name" and "url"
@@ skipping 37 matching lines @@
 #
 #   Example:
 #     hooks = [
 #       { "pattern": "\\.(gif|jpe?g|pr0n|png)$",
 #         "action":  ["python", "image_indexer.py", "--all"]},
 #       { "pattern": ".",
 #         "name": "gyp",
 #         "action":  ["python", "src/build/gyp_chromium"]},
 #     ]
 #
-# Pre-DEPS Hooks
-#   DEPS files may optionally contain a list named "pre_deps_hooks".  These are
-#   the same as normal hooks, except that they run before the DEPS are
-#   processed. Pre-DEPS run with "sync" and "revert" unless the --noprehooks
-#   flag is used.
-# 
 # Specifying a target OS
 #   An optional key named "target_os" may be added to a gclient file to specify
 #   one or more additional operating systems that should be considered when
 #   processing the deps_os dict of a DEPS file.
 #
 #   Example:
 #     target_os = [ "android" ]
 #
 #   If the "target_os_only" key is also present and true, then *only* the
 #   operating systems listed in "target_os" will be used.
@@ skipping 211 matching lines @@
   def __init__(self, parent, name, url, safesync_url, managed, custom_deps,
                custom_vars, custom_hooks, deps_file, should_process):
     gclient_utils.WorkItem.__init__(self, name)
     DependencySettings.__init__(
         self, parent, url, safesync_url, managed, custom_deps, custom_vars,
         custom_hooks, deps_file, should_process)
 
     # This is in both .gclient and DEPS files:
     self._deps_hooks = []
 
-    self._pre_deps_hooks = []
-
     # Calculates properties:
     self._parsed_url = None
     self._dependencies = []
     # A cache of the files affected by the current operation, necessary for
     # hooks.
     self._file_list = []
     # If it is not set to True, the dependency wasn't processed for its child
     # dependency, i.e. its DEPS wasn't read.
     self._deps_parsed = False
     # This dependency has been processed, i.e. checked out
     self._processed = False
-    # This dependency had its pre-DEPS hooks run
-    self._pre_deps_hooks_ran = False
     # This dependency had its hook run
     self._hooks_ran = False
     # This is the scm used to checkout self.url. It may be used by dependencies
     # to get the datetime of the revision we checked out.
     self._used_scm = None
     # The actual revision we ended up getting, or None if that information is
     # unavailable
     self._got_revision = None
 
     if not self.name and self.parent:
@@ skipping 231 matching lines @@
     hook_names_to_suppress = [c.get('name', '') for c in self.custom_hooks]
     for hook in local_scope.get('hooks', []):
       if hook.get('name', '') not in hook_names_to_suppress:
         hooks_to_run.append(hook)
 
     # add the replacements and any additions
     for hook in self.custom_hooks:
       if 'action' in hook:
         hooks_to_run.append(hook)
 
-    self._pre_deps_hooks = [self.GetHookAction(hook, []) for hook in
-                            local_scope.get('pre_deps_hooks', [])]
-
     self.add_dependencies_and_close(deps_to_add, hooks_to_run)
     logging.info('ParseDepsFile(%s) done' % self.name)
 
   def add_dependencies_and_close(self, deps_to_add, hooks):
     """Adds the dependencies, hooks and mark the parsing as done."""
     for dep in deps_to_add:
       if dep.verify_validity():
         self.add_dependency(dep)
     self._mark_as_parsed(hooks)
 
@@ skipping 80 matching lines @@
           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:]
 
     # Always parse the DEPS file.
     self.ParseDepsFile()
+
     self._run_is_done(file_list or [], parsed_url)
-    if command in ('update', 'revert') and not options.noprehooks:
-      self.RunPreDepsHooks()
 
     if self.recursion_limit:
       # Parse the dependencies of this dependency.
       for s in self.dependencies:
         work_queue.enqueue(s)
 
     if command == 'recurse':
       if not isinstance(parsed_url, self.FileImpl):
         # Skip file only checkout.
         scm = gclient_scm.GetScmName(parsed_url)
@@ skipping 121 matching lines @@
         # failed.  Users of this script may wish to treat hook action failures
         # differently from VC failures.
         print >> sys.stderr, 'Error: %s' % str(e)
         sys.exit(2)
       finally:
         elapsed_time = time.time() - start_time
         if elapsed_time > 10:
           print "Hook '%s' took %.2f secs" % (
               gclient_utils.CommandToStr(hook), elapsed_time)
 
-  def RunPreDepsHooks(self):
-    assert self.processed
-    assert self.deps_parsed
-    assert not self.pre_deps_hooks_ran
-    assert not self.hooks_ran
-    for s in self.dependencies:
-      assert not s.processed
-    self._pre_deps_hooks_ran = True
-    for hook in self.pre_deps_hooks:
-      try:
-        start_time = time.time()
-        gclient_utils.CheckCallAndFilterAndHeader(
-            hook, cwd=self.root.root_dir, always=True)
-      except (gclient_utils.Error, subprocess2.CalledProcessError), e:
-        # Use a discrete exit status code of 2 to indicate that a hook action
-        # failed.  Users of this script may wish to treat hook action failures
-        # differently from VC failures.
-        print >> sys.stderr, 'Error: %s' % str(e)
-        sys.exit(2)
-      finally:
-        elapsed_time = time.time() - start_time
-        if elapsed_time > 10:
-          print "Hook '%s' took %.2f secs" % (
-              gclient_utils.CommandToStr(hook), elapsed_time)
-
-
   def subtree(self, include_all):
     """Breadth first recursion excluding root node."""
     dependencies = self.dependencies
     for d in dependencies:
       if d.should_process or include_all:
         yield d
     for d in dependencies:
       for i in d.subtree(include_all):
         yield i
 
@@ skipping 19 matching lines @@
   def dependencies(self):
     return tuple(self._dependencies)
 
   @property
   @gclient_utils.lockedmethod
   def deps_hooks(self):
     return tuple(self._deps_hooks)
 
   @property
   @gclient_utils.lockedmethod
-  def pre_deps_hooks(self):
-    return tuple(self._pre_deps_hooks)
-
-  @property
-  @gclient_utils.lockedmethod
   def parsed_url(self):
     return self._parsed_url
 
   @property
   @gclient_utils.lockedmethod
   def deps_parsed(self):
     """This is purely for debugging purposes. It's not used anywhere."""
     return self._deps_parsed
 
   @property
   @gclient_utils.lockedmethod
   def processed(self):
     return self._processed
 
   @property
   @gclient_utils.lockedmethod
-  def pre_deps_hooks_ran(self):
-    return self._pre_deps_hooks_ran
-
-  @property
-  @gclient_utils.lockedmethod
   def hooks_ran(self):
     return self._hooks_ran
 
   @property
   @gclient_utils.lockedmethod
   def file_list(self):
     return tuple(self._file_list)
 
   @property
   def used_scm(self):
@@ skipping 689 matching lines @@
     }
   }
 }
 """)
 def CMDsync(parser, args):
   """Checkout/update all modules."""
   parser.add_option('-f', '--force', action='store_true',
                     help='force update even for unchanged modules')
   parser.add_option('-n', '--nohooks', action='store_true',
                     help='don\'t run hooks after the update is complete')
-  parser.add_option('-p', '--noprehooks', action='store_true',
-                    help='don\'t run pre-DEPS hooks', default=False)
   parser.add_option('-r', '--revision', action='append',
                     dest='revisions', metavar='REV', default=[],
                     help='Enforces revision/hash for the solutions with the '
                          'format src@rev. The src@ part is optional and can be '
                          'skipped. -r can be used multiple times when .gclient '
                          'has multiple solutions configured and will work even '
                          'if the src@ part is skipped. Note that specifying '
                          '--revision means your safesync_url gets ignored.')
   parser.add_option('--with_branch_heads', action='store_true',
                     help='Clone git "branch_heads" refspecs in addition to '
@@ skipping 85 matching lines @@
   """Reverts all modifications in every dependencies.
 
   That's the nuclear option to get back to a 'clean' state. It removes anything
   that shows up in svn status."""
   parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
                     help='override deps for the specified (comma-separated) '
                          'platform(s); \'all\' will process all deps_os '
                          'references')
   parser.add_option('-n', '--nohooks', action='store_true',
                     help='don\'t run hooks after the revert is complete')
-  parser.add_option('-p', '--noprehooks', action='store_true',
-                    help='don\'t run pre-DEPS hooks', default=False)
   parser.add_option('--upstream', action='store_true',
                     help='Make repo state match upstream branch.')
   (options, args) = parser.parse_args(args)
   # --force is implied.
   options.force = True
   options.reset = False
   options.delete_unversioned_trees = False
   client = GClient.LoadCurrentConfig(options)
   if not client:
     raise gclient_utils.Error('client not configured; see \'gclient config\'')
@@ skipping 113 matching lines @@
       self.error('--jobs must be 1 or higher')
 
     # These hacks need to die.
     if not hasattr(options, 'revisions'):
       # GClient.RunOnDeps expects it even if not applicable.
       options.revisions = []
     if not hasattr(options, 'head'):
       options.head = None
     if not hasattr(options, 'nohooks'):
       options.nohooks = True
-    if not hasattr(options, 'noprehooks'):
-      options.noprehooks = True
     if not hasattr(options, 'deps_os'):
       options.deps_os = None
     if not hasattr(options, 'manually_grab_svn_rev'):
       options.manually_grab_svn_rev = None
     if not hasattr(options, 'force'):
       options.force = None
     return (options, args)
 
 
 def disable_buffering():
@@ skipping 27 matching lines @@
     raise
   except (gclient_utils.Error, subprocess2.CalledProcessError), e:
     print >> sys.stderr, 'Error: %s' % str(e)
     return 1
 
 
 if '__main__' == __name__:
   sys.exit(Main(sys.argv[1:]))
 
 # vim: ts=2:sw=2:tw=80:et: