Fix unpinned version to track upstream.

gclient_scm.py

 # 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.
 
 """Gclient-specific SCM-specific operations."""
 
 import collections
 import logging
 import os
 import posixpath
@@ skipping 170 matching lines @@
     if not match:
       self.last_time = 0
     if (now - self.last_time) >= self.time_throttle:
       self.last_time = now
       print line
 
 
 class GitWrapper(SCMWrapper):
   """Wrapper for Git"""
   name = 'git'
+  remote = 'origin'
 
   cache_dir = None
   # If a given cache is used in a solution more than once, prevent multiple
   # threads from updating it simultaneously.
   cache_locks = collections.defaultdict(threading.Lock)
 
   def __init__(self, url=None, root_dir=None, relpath=None):
     """Removes 'git+' fake prefix from git URL."""
     if url.startswith('git+http://') or url.startswith('git+https://'):
       url = url[4:]
@@ skipping 22 matching lines @@
     return self._Capture(['log', '-n', '1', '--format=%ai'])
 
   @staticmethod
   def cleanup(options, args, file_list):
     """'Cleanup' the repo.
 
     There's no real git equivalent for the svn cleanup command, do a no-op.
     """
 
   def diff(self, options, _args, _file_list):
-    merge_base = self._Capture(['merge-base', 'HEAD', 'origin'])
+    merge_base = self._Capture(['merge-base', 'HEAD', self.remote])
     self._Run(['diff', merge_base], options)
 
   def pack(self, _options, _args, _file_list):
     """Generates a patch file which can be applied to the root of the
     repository.
 
     The patch file is generated from a diff of the merge base of HEAD and
     its upstream branch.
     """
-    merge_base = self._Capture(['merge-base', 'HEAD', 'origin'])
+    merge_base = self._Capture(['merge-base', 'HEAD', self.remote])
     gclient_utils.CheckCallAndFilter(
         ['git', 'diff', merge_base],
         cwd=self.checkout_path,
         filter_fn=GitDiffFilterer(self.relpath).Filter)
 
   def UpdateSubmoduleConfig(self):
     submod_cmd = ['git', 'config', '-f', '$toplevel/.git/config',
                   'submodule.$name.ignore', '||',
                   'git', 'config', '-f', '$toplevel/.git/config',
                   'submodule.$name.ignore', 'all']
@@ skipping 19 matching lines @@
     gclient_utils.CheckCallAndFilter(cmd4, **kwargs)
 
   def _FetchAndReset(self, revision, file_list, options):
     """Equivalent to git fetch; git reset."""
     quiet = []
     if not options.verbose:
       quiet = ['--quiet']
     self._UpdateBranchHeads(options, fetch=False)
 
     fetch_cmd = [
-      '-c', 'core.deltaBaseCacheLimit=2g', 'fetch', 'origin', '--prune']
+      '-c', 'core.deltaBaseCacheLimit=2g', 'fetch', self.remote, '--prune']
     self._Run(fetch_cmd + quiet, options, retry=True)
     self._Run(['reset', '--hard', revision] + quiet, options)
     self.UpdateSubmoduleConfig()
     if file_list is not None:
       files = self._Capture(['ls-files']).splitlines()
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def update(self, options, args, file_list):
     """Runs git to update or transparently checkout the working copy.
 
     All updated files will be appended to file_list.
 
     Raises:
       Error: if can't get URL for relative path.
     """
     if args:
       raise gclient_utils.Error("Unsupported argument(s): %s" % ",".join(args))
 
     self._CheckMinVersion("1.6.6")
 
-    default_rev = "refs/heads/master"
+    # If a dependency is not pinned, track the default remote branch.
+    default_rev = 'refs/remotes/%s/master' % self.remote
     url, deps_revision = gclient_utils.SplitUrlRevision(self.url)
     rev_str = ""
     revision = deps_revision
     managed = True
     if options.revision:
       # Override the revision number.
       revision = str(options.revision)
     if revision == 'unmanaged':
       revision = None
       managed = False
@@ skipping 15 matching lines @@
     verbose = []
     if options.verbose:
       print('\n_____ %s%s' % (self.relpath, rev_str))
       verbose = ['--verbose']
       printed_path = True
 
     url = self._CreateOrUpdateCache(url, options)
 
     if revision.startswith('refs/'):
       rev_type = "branch"
-    elif revision.startswith('origin/'):
-      # For compatability with old naming, translate 'origin' to 'refs/heads'
-      revision = revision.replace('origin/', 'refs/heads/')
+    elif revision.startswith(self.remote + '/'):
+      # For compatibility with old naming, translate 'origin' to 'refs/heads'
+      revision = revision.replace(self.remote + '/', 'refs/heads/')
       rev_type = "branch"
     else:
       # hash is also a tag, only make a distinction at checkout
       rev_type = "hash"
 
     if (not os.path.exists(self.checkout_path) or
         (os.path.isdir(self.checkout_path) and
          not os.path.exists(os.path.join(self.checkout_path, '.git')))):
       self._Clone(revision, url, options)
       self.UpdateSubmoduleConfig()
@@ skipping 15 matching lines @@
     if not os.path.exists(os.path.join(self.checkout_path, '.git')):
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\tPath is not a git repo. No .git dir.\n'
                                 '\tTo resolve:\n'
                                 '\t\trm -rf %s\n'
                                 '\tAnd run gclient sync again\n'
                                 % (self.relpath, rev_str, self.relpath))
 
     # See if the url has changed (the unittests use git://foo for the url, let
     # that through).
-    current_url = self._Capture(['config', 'remote.origin.url'])
+    current_url = self._Capture(['config', 'remote.%s.url' % self.remote])
     return_early = False
     # TODO(maruel): Delete url != 'git://foo' since it's just to make the
     # unit test pass. (and update the comment above)
     # Skip url auto-correction if remote.origin.gclient-auto-fix-url is set.
     # This allows devs to use experimental repos which have a different url
     # but whose branch(s) are the same as official repos.
     if (current_url != url and
         url != 'git://foo' and
         subprocess2.capture(
-            ['git', 'config', 'remote.origin.gclient-auto-fix-url'],
+            ['git', 'config', 'remote.%s.gclient-auto-fix-url' % self.remote],
             cwd=self.checkout_path).strip() != 'False'):
       print('_____ switching %s to a new upstream' % self.relpath)
       # Make sure it's clean
       self._CheckClean(rev_str)
       # Switch over to the new upstream
-      self._Run(['remote', 'set-url', 'origin', url], options)
+      self._Run(['remote', 'set-url', self.remote, url], options)
       self._FetchAndReset(revision, file_list, options)
       return_early = True
 
     # Need to do this in the normal path as well as in the post-remote-switch
     # path.
     self._PossiblySwitchCache(url, options)
 
     if return_early:
       return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
@@ skipping 61 matching lines @@
       # case 1
       if scm.GIT.IsGitSvn(self.checkout_path) and upstream_branch is not None:
         # Our git-svn branch (upstream_branch) is our upstream
         self._AttemptRebase(upstream_branch, files, options,
                             newbase=revision, printed_path=printed_path)
         printed_path = True
       else:
         # Can't find a merge-base since we don't know our upstream. That makes
         # this command VERY likely to produce a rebase failure. For now we
         # assume origin is our upstream since that's what the old behavior was.
-        upstream_branch = 'origin'
+        upstream_branch = self.remote
         if options.revision or deps_revision:
           upstream_branch = revision
         self._AttemptRebase(upstream_branch, files, options,
                             printed_path=printed_path)
         printed_path = True
     elif rev_type == 'hash':
       # case 2
       self._AttemptRebase(upstream_branch, files, options,
                           newbase=revision, printed_path=printed_path)
       printed_path = True
-    elif revision.replace('heads', 'remotes/origin') != upstream_branch:
+    elif revision.replace('heads', 'remotes/' + self.remote) != upstream_branch:
       # case 4
-      new_base = revision.replace('heads', 'remotes/origin')
+      new_base = revision.replace('heads', 'remotes/' + self.remote)
       if not printed_path:
         print('\n_____ %s%s' % (self.relpath, rev_str))
       switch_error = ("Switching upstream branch from %s to %s\n"
                      % (upstream_branch, new_base) +
                      "Please merge or rebase manually:\n" +
                      "cd %s; git rebase %s\n" % (self.checkout_path, new_base) +
                      "OR git checkout -b <some new branch> %s" % new_base)
       raise gclient_utils.Error(switch_error)
     else:
       # case 3 - the default case
@@ skipping 106 matching lines @@
 
     default_rev = "refs/heads/master"
     if options.upstream:
       if self._GetCurrentBranch():
         upstream_branch = scm.GIT.GetUpstreamBranch(self.checkout_path)
         default_rev = upstream_branch or default_rev
     _, deps_revision = gclient_utils.SplitUrlRevision(self.url)
     if not deps_revision:
       deps_revision = default_rev
     if deps_revision.startswith('refs/heads/'):
-      deps_revision = deps_revision.replace('refs/heads/', 'origin/')
+      deps_revision = deps_revision.replace('refs/heads/', self.remote + '/')
 
     if file_list is not None:
       files = self._Capture(['diff', deps_revision, '--name-only']).split()
 
     self._Run(['reset', '--hard', deps_revision], options)
     self._Run(['clean', '-f', '-d'], options)
 
     if file_list is not None:
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def revinfo(self, _options, _args, _file_list):
     """Returns revision"""
     return self._Capture(['rev-parse', 'HEAD'])
 
   def runhooks(self, options, args, file_list):
     self.status(options, args, file_list)
 
   def status(self, options, _args, file_list):
     """Display status information."""
     if not os.path.isdir(self.checkout_path):
       print(('\n________ couldn\'t run status in %s:\n'
              'The directory does not exist.') % self.checkout_path)
     else:
-      merge_base = self._Capture(['merge-base', 'HEAD', 'origin'])
+      merge_base = self._Capture(['merge-base', 'HEAD', self.remote])
       self._Run(['diff', '--name-status', merge_base], options)
       if file_list is not None:
         files = self._Capture(['diff', '--name-only', merge_base]).split()
         file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def GetUsableRev(self, rev, options):
     """Finds a useful revision for this repository.
 
     If SCM is git-svn and the head revision is less than |rev|, git svn fetch
     will be called on the source."""
@@ skipping 37 matching lines @@
               ( 'It appears that either your git-svn remote is incorrectly\n'
                 'configured or the revision in your safesync_url is\n'
                 'higher than git-svn remote\'s HEAD as we couldn\'t find a\n'
                 'corresponding git hash for SVN rev %s.' ) % rev)
     else:
       if scm.GIT.IsValidRevision(cwd=self.checkout_path, rev=rev):
         sha1 = rev
       else:
         # May exist in origin, but we don't have it yet, so fetch and look
         # again.
-        scm.GIT.Capture(['fetch', 'origin'], cwd=self.checkout_path)
+        scm.GIT.Capture(['fetch', self.remote], cwd=self.checkout_path)
         if scm.GIT.IsValidRevision(cwd=self.checkout_path, rev=rev):
           sha1 = rev
 
     if not sha1:
       raise gclient_utils.Error(
           ( 'We could not find a valid hash for safesync_url response "%s".\n'
             'Safesync URLs with a git checkout currently require a git-svn\n'
             'remote or a safesync_url that provides git sha1s. Please add a\n'
             'git-svn remote or change your safesync_url. For more info, see:\n'
             'http://code.google.com/p/chromium/wiki/UsingNewGit'
@@ skipping 91 matching lines @@
         if use_reference:
           cmd += ['--reference', os.path.abspath(self.checkout_path)]
 
         self._Run(cmd + [url, folder],
                   options, filter_fn=filter_fn, cwd=self.cache_dir, retry=True)
       else:
         # For now, assert that host/path/to/repo.git is identical. We may want
         # to relax this restriction in the future to allow for smarter cache
         # repo update schemes (such as pulling the same repo, but from a
         # different host).
-        existing_url = self._Capture(['config', 'remote.origin.url'],
+        existing_url = self._Capture(['config', 'remote.%s.url' % self.remote],
                                      cwd=folder)
         assert self._NormalizeGitURL(existing_url) == self._NormalizeGitURL(url)
 
         if use_reference:
           with open(altfile, 'w') as f:
             f.write(os.path.abspath(checkout_objects))
 
         # Would normally use `git remote update`, but it doesn't support
         # --progress, so use fetch instead.
         self._Run(['fetch'] + v + ['--multiple', '--progress', '--all'],
@@ skipping 46 matching lines @@
       gclient_utils.rmtree(tmp_dir)
     if revision.startswith('refs/heads/'):
       self._Run(
           ['checkout', '--quiet', revision.replace('refs/heads/', '')], options)
     else:
       # Squelch git's very verbose detached HEAD warning and use our own
       self._Run(['checkout', '--quiet', revision], options)
       print(
         ('Checked out %s to a detached HEAD. Before making any commits\n'
          'in this repo, you should use \'git checkout <branch>\' to switch to\n'
-         'an existing branch or use \'git checkout origin -b <branch>\' to\n'
-         'create a new branch for your work.') % revision)
+         'an existing branch or use \'git checkout %s -b <branch>\' to\n'
+         'create a new branch for your work.') % (revision, self.remote))
 
   def _AttemptRebase(self, upstream, files, options, newbase=None,
                      branch=None, printed_path=False):
     """Attempt to rebase onto either upstream or, if specified, newbase."""
     if files is not None:
       files.extend(self._Capture(['diff', upstream, '--name-only']).split())
     revision = upstream
     if newbase:
       revision = newbase
     if not printed_path:
@@ skipping 128 matching lines @@
 
   def _Capture(self, args, cwd=None):
     return subprocess2.check_output(
         ['git'] + args,
         stderr=subprocess2.VOID,
         cwd=cwd or self.checkout_path).strip()
 
   def _UpdateBranchHeads(self, options, fetch=False):
     """Adds, and optionally fetches, "branch-heads" refspecs if requested."""
     if hasattr(options, 'with_branch_heads') and options.with_branch_heads:
-      config_cmd = ['config', 'remote.origin.fetch',
+      config_cmd = ['config', 'remote.%s.fetch' % self.remote,
                     '+refs/branch-heads/*:refs/remotes/branch-heads/*',
                     '^\\+refs/branch-heads/\\*:.*$']
       self._Run(config_cmd, options)
       if fetch:
-        fetch_cmd = ['-c', 'core.deltaBaseCacheLimit=2g', 'fetch', 'origin']
+        fetch_cmd = ['-c', 'core.deltaBaseCacheLimit=2g', 'fetch', self.remote]
         if options.verbose:
           fetch_cmd.append('--verbose')
         self._Run(fetch_cmd, options, retry=True)
 
   def _Run(self, args, options, **kwargs):
     kwargs.setdefault('cwd', self.checkout_path)
     git_filter = not options.verbose
     if git_filter:
       kwargs['filter_fn'] = GitFilter(kwargs.get('filter_fn'))
       kwargs.setdefault('print_stdout', False)
@@ skipping 407 matching lines @@
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'theirs-conflict'))
     elif options.manually_grab_svn_rev:
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'postpone'))
     elif command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
       new_command.extend(('--accept', 'postpone'))
     return new_command