Add Dependency.requirements which will solve the issues found in pagespeed and parallel checkout.

gclient.py

 #!/usr/bin/python
 # Copyright (c) 2010 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 36 matching lines @@
       { "pattern": "\\.(gif|jpe?g|pr0n|png)$",
         "action":  ["python", "image_indexer.py", "--all"]},
     ]
 """
 
 __version__ = "0.5"
 
 import logging
 import optparse
 import os
+import posixpath
 import pprint
 import re
 import subprocess
 import sys
 import urlparse
 import urllib
 
 import breakpad
 
 import gclient_scm
@@ skipping 91 matching lines @@
     # dependency, i.e. its DEPS wasn't read.
     self.deps_parsed = False
     # A direct reference is dependency that is referenced by a deps, deps_os or
     # solution. A indirect one is one that was loaded with From() or that
     # exceeded recursion limit.
     self.direct_reference = False
     # This dependency has been processed, i.e. checked out
     self.processed = False
     # This dependency had its hook run
     self.hooks_ran = False
+    # Required dependencies to run before running this one:
+    self.requirements = []
+    if self.parent and self.parent.name:
+      self.requirements.append(self.parent.name)
+    if isinstance(self.url, self.FromImpl):
+      self.requirements.append(self.url.module_name)
 
     # Sanity checks
     if not self.name and self.parent:
       raise gclient_utils.Error('Dependency without name')
     if not isinstance(self.url,
         (basestring, self.FromImpl, self.FileImpl, None.__class__)):
       raise gclient_utils.Error('dependency url must be either a string, None, '
                                 'File() or From() instead of %s' %
                                 self.url.__class__.__name__)
     if '/' in self.deps_file or '\\' in self.deps_file:
@@ skipping 177 matching lines @@
       # itself, .i.e. this code is called one time for the .gclient. This is not
       # conceptually correct but it simplifies code.
       pm._total = len(self.tree(False)) + 1
       pm.update()
     if self.recursion_limit():
       # Then we can parse the DEPS file.
       self.ParseDepsFile(True)
       if pm:
         pm._total = len(self.tree(False)) + 1
         pm.update(0)
+      # Adjust the implicit dependency requirement; e.g. if a DEPS file contains
+      # both src/foo and src/foo/bar, src/foo/bar is implicitly dependent of
+      # src/foo. Yes, it's O(n^2)...

[bradn, 2010/08/10 20:21:02]

Wait so, do I understand correctly that a sort won't work here because its
ordering is too strict (there recursive deps targets that have to come first
because you don't know about the repos they pull in?) Wanna make sure I
understand.

[M-A Ruel, 2010/08/10 20:28:45]

Yes. In pagespeed, they have something like that:

deps = {
 'src/third_party/chromium_deps: File('...chrome/trunk/src/DEPS'),
 'src/googleurl': From('src/chromium_deps')
}

That just doesn't work when the list is sorted. But just not sorting doesn't
work either, webkit.org's DEPS has other similar issues, hence the exact list of
requirements.

More details at:
http://code.google.com/p/page-speed/source/browse/lib/trunk/src/DEPS

+      for s in self.dependencies:
+        for s2 in self.dependencies:
+          if s is s2:
+            continue
+          if s.name.startswith(posixpath.join(s2.name, '')):
+            s.requirements.append(s2.name)
+
       # Parse the dependencies of this dependency.
       for s in self.dependencies:
         # TODO(maruel): All these can run concurrently! No need for threads,
         # just buffer stdout&stderr on pipes and flush as they complete.
         # Watch out for stdin.
         s.RunCommandRecursively(options, revision_overrides, command, args, pm)
 
   def RunHooksRecursively(self, options):
     """Evaluates all hooks, running actions as needed. RunCommandRecursively()
     must have been called before to load the DEPS."""
@@ skipping 94 matching lines @@
   def file_list(self):
     result = self._file_list[:]
     for d in self.dependencies:
       result.extend(d.file_list())
     return result
 
   def __str__(self):
     out = []
     for i in ('name', 'url', 'parsed_url', 'safesync_url', 'custom_deps',
               'custom_vars', 'deps_hooks', '_file_list', 'processed',
-              'hooks_ran', 'deps_parsed'):
+              'hooks_ran', 'deps_parsed', 'requirements'):
       # 'deps_file'
       if self.__dict__[i]:
         out.append('%s: %s' % (i, self.__dict__[i]))
 
     for d in self.dependencies:
       out.extend(['  ' + x for x in str(d).splitlines()])
       out.append('')
     return '\n'.join(out)
 
   def __repr__(self):
@@ skipping 704 matching lines @@
     return CMDhelp(parser, argv)
   except gclient_utils.Error, 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: