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 268 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 not options.nohooks:
+      self.RunPreDepsHooks()

[iannucci, 2013/10/07 22:40:09]

So, the bots generally run with --nohooks. If we want to use this for the bots
then maybe we should have a --noprehooks flag?

[borenet, 2013/10/08 13:53:19]

This sounds fine to me, if adding another flag is alright.

 
     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 974 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: