Add workaround to ignore the first solution specified with --revision solution@rev

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.
 
 """A wrapper script to manage a set of client modules in different SCM.
 
 This script is intended to be used to help basic management of client
 program sources residing in one or more Subversion modules and Git
 repositories, along with other modules it depends on, also in Subversion or Git,
@@ skipping 485 matching lines @@
       return
 
     # Run hooks on the basis of whether the files from the gclient operation
     # match each hook's pattern.
     for hook_dict in hooks:
       pattern = re.compile(hook_dict['pattern'])
       matching_file_list = [f for f in file_list if pattern.search(f)]
       if matching_file_list:
         self._RunHookAction(hook_dict, matching_file_list)
 
+  def _EnforceRevisions(self, solutions):
+    """Checks for revision overrides."""
+    revision_overrides = {}
+    solutions = [s['name'] for s in solutions]
+    if self._options.revisions:
+      revision = self._options.revisions[0]
+      # Ignore solution@
+      rev = revision
+      if '@' in revision:
+        rev = revision.split('@', 1)[1]
+      revision_overrides[solutions[0]] = rev
+
+    if len(self._options.revisions) > 1:
+      # Enforce solution@rev format for following params.
+      for revision in self._options.revisions[1:]:
+        if not '@' in revision:
+          raise gclient_utils.Error(
+              'Specify the full dependency when specifying a revision number '
+              'for non-primary solution.')
+        sol, rev = revision.split("@", 1)
+        # Disallow conflicting revs
+        if revision_overrides.get(sol, rev) != rev:
+          raise gclient_utils.Error(
+              'Conflicting revision numbers specified for %s: %s and %s.' %
+                  (sol, revision_overrides[sol], rev))
+        if not sol in solutions:
+          raise gclient_utils.Error('%s is not a valid solution.' % sol)
+        revision_overrides[sol] = rev
+    return revision_overrides
+
   def RunOnDeps(self, command, args):
     """Runs a command on each dependency in a client and its dependencies.
 
     The module's dependencies are specified in its top-level DEPS files.
 
     Args:
       command: The command to use (e.g., 'status' or 'diff')
       args: list of str - extra arguments to add to the command line.
 
     Raises:
       Error: If the client has conflicting entries.
     """
     if not command in self.supported_commands:
       raise gclient_utils.Error("'%s' is an unsupported command" % command)
 
-    # Check for revision overrides.
-    revision_overrides = {}
-    for revision in self._options.revisions:
-      if revision.find("@") == -1:
-        raise gclient_utils.Error(
-            "Specify the full dependency when specifying a revision number.")
-      revision_elem = revision.split("@")
-      # Disallow conflicting revs
-      if revision_overrides.has_key(revision_elem[0]) and \
-         revision_overrides[revision_elem[0]] != revision_elem[1]:
-        raise gclient_utils.Error(
-            "Conflicting revision numbers specified.")
-      revision_overrides[revision_elem[0]] = revision_elem[1]
-
     solutions = self.GetVar("solutions")
     if not solutions:
       raise gclient_utils.Error("No solution specified")
+    revision_overrides = self._EnforceRevisions(solutions)
 
     # When running runhooks --force, 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 = not (command == 'runhooks' and self._options.force)
 
     entries = {}
     entries_deps_content = {}
     file_list = []
     # Run on the base solutions first.
@@ skipping 124 matching lines @@
             print("\n________ deleting \'%s\' " +
                   "in \'%s\'") % (entry_fixed, self._root_dir)
             gclient_utils.RemoveDirectory(e_dir)
       # record the current list of entries for next time
       self._SaveEntries(entries)
 
   def PrintRevInfo(self):
     """Output revision info mapping for the client and its dependencies.
 
     This allows the capture of an overall "revision" for the source tree that
-    can be used to reproduce the same tree in the future. The actual output
-    contains enough information (source paths, svn server urls and revisions)
-    that it can be used either to generate external svn/git commands (without
-    gclient) or as input to gclient's --rev option (with some massaging of
-    the data).
-
-    Since we care about the revision of the current source tree, for git
-    repositories this command uses the revision of the HEAD. For subversion we
-    use BASE.
+    can be used to reproduce the same tree in the future. It is only useful for
+    "unpinned dependencies", i.e. DEPS/deps references without a svn revision
+    number or a git hash. A git branch name isn't "pinned" since the actual
+    commit can change.
 
     The --snapshot option allows creating a .gclient file to reproduce the tree.
-
-    Raises:
-      Error: If the client has conflicting entries.
     """
-    # Check for revision overrides.
-    revision_overrides = {}
-    for revision in self._options.revisions:
-      if revision.find("@") < 0:
-        raise gclient_utils.Error(
-            "Specify the full dependency when specifying a revision number.")
-      revision_elem = revision.split("@")
-      # Disallow conflicting revs
-      if revision_overrides.has_key(revision_elem[0]) and \
-         revision_overrides[revision_elem[0]] != revision_elem[1]:
-        raise gclient_utils.Error(
-            "Conflicting revision numbers specified.")
-      revision_overrides[revision_elem[0]] = revision_elem[1]
-
     solutions = self.GetVar("solutions")
     if not solutions:
       raise gclient_utils.Error("No solution specified")
 
     # Inner helper to generate base url and rev tuple
     def GetURLAndRev(name, original_url):
       url, _ = gclient_utils.SplitUrlRevision(original_url)
       scm = gclient_scm.CreateSCM(original_url, self._root_dir, name)
       return (url, scm.revinfo(self._options, [], None))
 
@@ skipping 205 matching lines @@
       update src directory to r31000
 """)
 def CMDsync(parser, args):
   """Checkout/update all modules."""
   parser.add_option("--force", action="store_true",
                     help="force update even for unchanged modules")
   parser.add_option("--nohooks", action="store_true",
                     help="don't run hooks after the update is complete")
   parser.add_option("-r", "--revision", action="append",
                     dest="revisions", metavar="REV", default=[],
-                    help="update given solution to specified revision, "
-                         "can be used multiple times for each solution, "
-                         "e.g. -r src@123, -r internal@32")
+                    help="Enforces revision/hash for the primary solution. "
+                         "To modify a secondary solution, use it at least once "
+                         "for the primary solution and then use the format "
+                         "solution@rev/hash, e.g. -r src@123")
   parser.add_option("--head", action="store_true",
                     help="skips any safesync_urls specified in "
                          "configured solutions and sync to head instead")
   parser.add_option("--delete_unversioned_trees", action="store_true",
                     help="delete any unexpected unversioned trees "
                          "that are in the checkout")
   parser.add_option("--reset", action="store_true",
                     help="resets any local changes before updating (git only)")
   parser.add_option("--deps", dest="deps_os", metavar="OS_LIST",
                     help="sync deps for the specified (comma-separated) "
                          "platform(s); 'all' will sync all platforms")
   parser.add_option("--manually_grab_svn_rev", action="store_true",
                     help="Skip svn up whenever possible by requesting "
                          "actual HEAD revision from the repository")
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
 
   if not client:
     raise gclient_utils.Error("client not configured; see 'gclient config'")
 
   if not options.head:
     solutions = client.GetVar('solutions')
     if solutions:
+      first = True
       for s in solutions:
-        if s.get('safesync_url', ''):
+        if s.get('safesync_url', None):
           # rip through revisions and make sure we're not over-riding
           # something that was explicitly passed
           has_key = False
+          r_first = True
           for r in options.revisions:
-            if r.split('@')[0] == s['name']:
+            if (first and r_first) or r.split('@', 1)[0] == s['name']:
               has_key = True
               break
+            r_first = False
 
           if not has_key:
             handle = urllib.urlopen(s['safesync_url'])
             rev = handle.read().strip()
             handle.close()
             if len(rev):
               options.revisions.append(s['name']+'@'+rev)
+        first = False
 
   if options.verbose:
     # Print out the .gclient file.  This is longer than if we just printed the
     # client dict, but more legible, and it might contain helpful comments.
     print(client.ConfigContent())
   return client.RunOnDeps('update', args)
 
 
 def CMDupdate(parser, args):
   """Alias for the sync command. Deprecated."""
@@ skipping 128 matching lines @@
 
 
 if "__main__" == __name__:
   try:
     sys.exit(Main(sys.argv[1:]))
   except gclient_utils.Error, e:
     print >> sys.stderr, "Error: %s" % str(e)
     sys.exit(1)
 
 # vim: ts=2:sw=2:tw=80:et: