libv8 4.5.95.5 → 5.0.71.48.0beta2

data/vendor/depot_tools/gclient_scm.py

@@ -30,6 +30,10 @@ GSUTIL_DEFAULT_PATH = os.path.join(
     os.path.dirname(os.path.abspath(__file__)), 'gsutil.py')
 
 
+class NoUsableRevError(gclient_utils.Error):
+  """Raised if requested revision isn't found in checkout."""
+
+
 class DiffFiltererWrapper(object):
   """Simple base class which tracks which file is being diffed and
   replaces instances of its file name in the original and
@@ -323,6 +327,27 @@ class GitWrapper(SCMWrapper):
           os.remove(disabled_hook_path)
         os.rename(os.path.join(hook_dir, f), disabled_hook_path)
 
+  def _maybe_break_locks(self, options):
+    """This removes all .lock files from this repo's .git directory, if the
+    user passed the --break_repo_locks command line flag.
+
+    In particular, this will cleanup index.lock files, as well as ref lock
+    files.
+    """
+    if options.break_repo_locks:
+      git_dir = os.path.join(self.checkout_path, '.git')
+      for path, _, filenames in os.walk(git_dir):
+        for filename in filenames:
+          if filename.endswith('.lock'):
+            to_break = os.path.join(path, filename)
+            self.Print('breaking lock: %s' % (to_break,))
+            try:
+              os.remove(to_break)
+            except OSError as ex:
+              self.Print('FAILED to break lock: %s: %s' % (to_break, ex))
+              raise
+
+
   def update(self, options, args, file_list):
     """Runs git to update or transparently checkout the working copy.
 
@@ -429,6 +454,8 @@ class GitWrapper(SCMWrapper):
       self.Print('________ unmanaged solution; skipping %s' % self.relpath)
       return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
+    self._maybe_break_locks(options)
+
     if mirror:
       self._UpdateMirror(mirror, options)
 
@@ -457,8 +484,12 @@ class GitWrapper(SCMWrapper):
             self.checkout_path, '.git', 'objects', 'info', 'alternates'),
             'w') as fh:
           fh.write(os.path.join(url, 'objects'))
+      self._EnsureValidHeadObjectOrCheckout(revision, options, url)
       self._FetchAndReset(revision, file_list, options)
+
       return_early = True
+    else:
+      self._EnsureValidHeadObjectOrCheckout(revision, options, url)
 
     if return_early:
       return self._Capture(['rev-parse', '--verify', 'HEAD'])
@@ -511,7 +542,7 @@ class GitWrapper(SCMWrapper):
       if verbose:
         self.Print(remote_output)
 
-      self._UpdateBranchHeads(options, fetch=True)
+    self._UpdateBranchHeads(options, fetch=True)
 
     # This is a big hammer, debatable if it should even be here...
     if options.force or options.reset:
@@ -522,7 +553,9 @@ class GitWrapper(SCMWrapper):
 
     if current_type == 'detached':
       # case 0
-      self._CheckClean(rev_str)
+      if not options.force:
+        # Don't do this check if nuclear option is on.
+        self._CheckClean(rev_str)
       self._CheckDetachedHead(rev_str, options)
       if self._Capture(['rev-list', '-n', '1', 'HEAD']) == revision:
         self.Print('Up-to-date; skipping checkout.')
@@ -532,7 +565,7 @@ class GitWrapper(SCMWrapper):
         self._Checkout(
             options,
             revision,
-            force=(options.force and options.delete_unversioned_trees),
+            force=(options.force or options.delete_unversioned_trees),
             quiet=True,
         )
       if not printed_path:
@@ -717,7 +750,15 @@ class GitWrapper(SCMWrapper):
       deps_revision = default_rev
     if deps_revision.startswith('refs/heads/'):
       deps_revision = deps_revision.replace('refs/heads/', self.remote + '/')
-    deps_revision = self.GetUsableRev(deps_revision, options)
+    try:
+      deps_revision = self.GetUsableRev(deps_revision, options)
+    except NoUsableRevError as e:
+      # If the DEPS entry's url and hash changed, try to update the origin.
+      # See also http://crbug.com/520067.
+      logging.warn(
+          'Couldn\'t find usable revision, will retrying to update instead: %s',
+          e.message)
+      return self.update(options, [], file_list)
 
     if file_list is not None:
       files = self._Capture(['diff', deps_revision, '--name-only']).split()
@@ -755,7 +796,7 @@ class GitWrapper(SCMWrapper):
     will be called on the source."""
     sha1 = None
     if not os.path.isdir(self.checkout_path):
-      raise gclient_utils.Error(
+      raise NoUsableRevError(
           ( 'We could not find a valid hash for safesync_url response "%s".\n'
             'Safesync URLs with a git checkout currently require the repo to\n'
             'be cloned without a safesync_url before adding the safesync_url.\n'
@@ -789,7 +830,7 @@ class GitWrapper(SCMWrapper):
                  'the closest sane git revision, which is:\n'
                  '  %s\n' % (rev, e.message))
         if not sha1:
-          raise gclient_utils.Error(
+          raise NoUsableRevError(
               ( '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'
@@ -805,7 +846,7 @@ class GitWrapper(SCMWrapper):
           sha1 = rev
 
     if not sha1:
-      raise gclient_utils.Error(
+      raise NoUsableRevError(
           ( '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'
@@ -855,7 +896,8 @@ class GitWrapper(SCMWrapper):
     mirror.populate(verbose=options.verbose,
                     bootstrap=not getattr(options, 'no_bootstrap', False),
                     depth=depth,
-                    ignore_lock=getattr(options, 'ignore_locks', False))
+                    ignore_lock=getattr(options, 'ignore_locks', False),
+                    lock_timeout=getattr(options, 'lock_timeout', 0))
     mirror.unlock()
 
   def _Clone(self, revision, url, options):
@@ -1027,6 +1069,29 @@ class GitWrapper(SCMWrapper):
       raise gclient_utils.Error('git version %s < minimum required %s' %
                                 (current_version, min_version))
 
+  def _EnsureValidHeadObjectOrCheckout(self, revision, options, url):
+    # Special case handling if all 3 conditions are met:
+    #   * the mirros have recently changed, but deps destination remains same,
+    #   * the git histories of mirrors are conflicting.
+    #   * git cache is used
+    # This manifests itself in current checkout having invalid HEAD commit on
+    # most git operations. Since git cache is used, just deleted the .git
+    # folder, and re-create it by cloning.
+    try:
+      self._Capture(['rev-list', '-n', '1', 'HEAD'])
+    except subprocess2.CalledProcessError as e:
+      if ('fatal: bad object HEAD' in e.stderr
+          and self.cache_dir and self.cache_dir in url):
+        self.Print((
+          'Likely due to DEPS change with git cache_dir, '
+          'the current commit points to no longer existing object.\n'
+          '%s' % e)
+        )
+        self._DeleteOrMove(options.force)
+        self._Clone(revision, url, options)
+      else:
+        raise
+
   def _IsRebasing(self):
     # Check for any of REBASE-i/REBASE-m/REBASE/AM. Unfortunately git doesn't
     # have a plumbing command to determine whether a rebase is in progress, so
@@ -1037,6 +1102,14 @@ class GitWrapper(SCMWrapper):
       os.path.isdir(os.path.join(g, "rebase-apply")))
 
   def _CheckClean(self, rev_str):
+    lockfile = os.path.join(self.checkout_path, ".git", "index.lock")
+    if os.path.exists(lockfile):
+      raise gclient_utils.Error(
+        '\n____ %s%s\n'
+        '\tYour repo is locked, possibly due to a concurrent git process.\n'
+        '\tIf no git executable is running, then clean up %r and try again.\n'
+        % (self.relpath, rev_str, lockfile))
+
     # Make sure the tree is clean; see git-rebase.sh for reference
     try:
       scm.GIT.Capture(['update-index', '--ignore-submodules', '--refresh'],
@@ -1173,7 +1246,7 @@ class SVNWrapper(SCMWrapper):
     'Oh hai! You are using subversion. Chrome infra is eager to get rid of',
     'svn support so please switch to git.',
     'Tracking bug: http://crbug.com/475320',
-    'Request a new git repository at: ',
+    'If you are a project owner, you may request git migration assistance at: ',
     '  https://code.google.com/p/chromium/issues/entry?template=Infra-Git')
 
   def __init__(self, *args, **kwargs):
@@ -1590,7 +1663,7 @@ class SVNWrapper(SCMWrapper):
   def GetUsableRev(self, rev, _options):
     """Verifies the validity of the revision for this repository."""
     if not scm.SVN.IsValidRevision(url='%s@%s' % (self.url, rev)):
-      raise gclient_utils.Error(
+      raise NoUsableRevError(
         ( '%s isn\'t a valid revision. Please check that your safesync_url is\n'
           'correct.') % rev)
     return rev

data/vendor/depot_tools/gclient_utils.py

@@ -1084,7 +1084,11 @@ def RunEditor(content, git, git_editor=None):
         '!! Please remove \\r from your change description !!')
   fileobj = os.fdopen(file_handle, 'w')
   # Still remove \r if present.
-  fileobj.write(re.sub('\r?\n', '\n', content))
+  content = re.sub('\r?\n', '\n', content)
+  # Some editors complain when the file doesn't end in \n.
+  if not content.endswith('\n'):
+    content += '\n'
+  fileobj.write(content)
   fileobj.close()
 
   try:

data/vendor/depot_tools/gerrit_util.py

@@ -9,42 +9,26 @@ https://gerrit-review.googlesource.com/Documentation/rest-api.html
 """
 
 import base64
+import cookielib
 import httplib
 import json
 import logging
 import netrc
 import os
 import re
+import socket
 import stat
 import sys
 import time
 import urllib
+import urlparse
 from cStringIO import StringIO
 
-_netrc_file = '_netrc' if sys.platform.startswith('win') else '.netrc'
-_netrc_file = os.path.join(os.environ['HOME'], _netrc_file)
-try:
-  NETRC = netrc.netrc(_netrc_file)
-except IOError:
-  print >> sys.stderr, 'WARNING: Could not read netrc file %s' % _netrc_file
-  NETRC = netrc.netrc(os.devnull)
-except netrc.NetrcParseError as e:
-  _netrc_stat = os.stat(e.filename)
-  if _netrc_stat.st_mode & (stat.S_IRWXG | stat.S_IRWXO):
-    print >> sys.stderr, (
-        'WARNING: netrc file %s cannot be used because its file permissions '
-        'are insecure.  netrc file permissions should be 600.' % _netrc_file)
-  else:
-    print >> sys.stderr, ('ERROR: Cannot use netrc file %s due to a parsing '
-                          'error.' % _netrc_file)
-    raise
-  del _netrc_stat
-  NETRC = netrc.netrc(os.devnull)
-del _netrc_file
 
 LOGGER = logging.getLogger()
 TRY_LIMIT = 5
 
+
 # Controls the transport protocol used to communicate with gerrit.
 # This is parameterized primarily to enable GerritTestCase.
 GERRIT_PROTOCOL = 'https'
@@ -84,17 +68,203 @@ def GetConnectionClass(protocol=None):
         "Don't know how to work with protocol '%s'" % protocol)
 
 
+class Authenticator(object):
+  """Base authenticator class for authenticator implementations to subclass."""
+
+  def get_auth_header(self, host):
+    raise NotImplementedError()
+
+  @staticmethod
+  def get():
+    """Returns: (Authenticator) The identified Authenticator to use.
+
+    Probes the local system and its environment and identifies the
+    Authenticator instance to use.
+    """
+    if GceAuthenticator.is_gce():
+      return GceAuthenticator()
+    return CookiesAuthenticator()
+
+
+class CookiesAuthenticator(Authenticator):
+  """Authenticator implementation that uses ".netrc" or ".gitcookies" for token.
+
+  Expected case for developer workstations.
+  """
+
+  def __init__(self):
+    self.netrc = self._get_netrc()
+    self.gitcookies = self._get_gitcookies()
+
+  @classmethod
+  def get_new_password_message(cls, host):
+    assert not host.startswith('http')
+    # Assume *.googlesource.com pattern.
+    parts = host.split('.')
+    if not parts[0].endswith('-review'):
+      parts[0] += '-review'
+    url = 'https://%s/new-password' % ('.'.join(parts))
+    return 'You can (re)generate your credentails by visiting %s' % url
+
+  @classmethod
+  def get_netrc_path(cls):
+    path = '_netrc' if sys.platform.startswith('win') else '.netrc'
+    return os.path.expanduser(os.path.join('~', path))
+
+  @classmethod
+  def _get_netrc(cls):
+    path = cls.get_netrc_path()
+    if not os.path.exists(path):
+      return netrc.netrc(os.devnull)
+
+    try:
+      return netrc.netrc(path)
+    except IOError:
+      print >> sys.stderr, 'WARNING: Could not read netrc file %s' % path
+      return netrc.netrc(os.devnull)
+    except netrc.NetrcParseError:
+      st = os.stat(path)
+      if st.st_mode & (stat.S_IRWXG | stat.S_IRWXO):
+        print >> sys.stderr, (
+            'WARNING: netrc file %s cannot be used because its file '
+            'permissions are insecure.  netrc file permissions should be '
+            '600.' % path)
+      else:
+        print >> sys.stderr, ('ERROR: Cannot use netrc file %s due to a '
+                              'parsing error.' % path)
+        raise
+      return netrc.netrc(os.devnull)
+
+  @classmethod
+  def get_gitcookies_path(cls):
+    return os.path.join(os.environ['HOME'], '.gitcookies')
+
+  @classmethod
+  def _get_gitcookies(cls):
+    gitcookies = {}
+    path = cls.get_gitcookies_path()
+    if not os.path.exists(path):
+      return gitcookies
+
+    try:
+      f = open(path, 'rb')
+    except IOError:
+      return gitcookies
+
+    with f:
+      for line in f:
+        try:
+          fields = line.strip().split('\t')
+          if line.strip().startswith('#') or len(fields) != 7:
+            continue
+          domain, xpath, key, value = fields[0], fields[2], fields[5], fields[6]
+          if xpath == '/' and key == 'o':
+            login, secret_token = value.split('=', 1)
+            gitcookies[domain] = (login, secret_token)
+        except (IndexError, ValueError, TypeError) as exc:
+          logging.warning(exc)
+
+    return gitcookies
+
+  def get_auth_header(self, host):
+    auth = None
+    for domain, creds in self.gitcookies.iteritems():
+      if cookielib.domain_match(host, domain):
+        auth = (creds[0], None, creds[1])
+        break
+
+    if not auth:
+      auth = self.netrc.authenticators(host)
+    if auth:
+      return 'Basic %s' % (base64.b64encode('%s:%s' % (auth[0], auth[2])))
+    return None
+
+# Backwards compatibility just in case somebody imports this outside of
+# depot_tools.
+NetrcAuthenticator = CookiesAuthenticator
+
+
+class GceAuthenticator(Authenticator):
+  """Authenticator implementation that uses GCE metadata service for token.
+  """
+
+  _INFO_URL = 'http://metadata.google.internal'
+  _ACQUIRE_URL = ('http://metadata/computeMetadata/v1/instance/'
+                  'service-accounts/default/token')
+  _ACQUIRE_HEADERS = {"Metadata-Flavor": "Google"}
+
+  _cache_is_gce = None
+  _token_cache = None
+  _token_expiration = None
+
+  @classmethod
+  def is_gce(cls):
+    if cls._cache_is_gce is None:
+      cls._cache_is_gce = cls._test_is_gce()
+    return cls._cache_is_gce
+
+  @classmethod
+  def _test_is_gce(cls):
+    # Based on https://cloud.google.com/compute/docs/metadata#runninggce
+    try:
+      resp = cls._get(cls._INFO_URL)
+    except socket.error:
+      # Could not resolve URL.
+      return False
+    return resp.getheader('Metadata-Flavor', None) == 'Google'
+
+  @staticmethod
+  def _get(url, **kwargs):
+    next_delay_sec = 1
+    for i in xrange(TRY_LIMIT):
+      if i > 0:
+        # Retry server error status codes.
+        LOGGER.info('Encountered server error; retrying after %d second(s).',
+                    next_delay_sec)
+        time.sleep(next_delay_sec)
+        next_delay_sec *= 2
+
+      p = urlparse.urlparse(url)
+      c = GetConnectionClass(protocol=p.scheme)(p.netloc)
+      c.request('GET', url, **kwargs)
+      resp = c.getresponse()
+      LOGGER.debug('GET [%s] #%d/%d (%d)', url, i+1, TRY_LIMIT, resp.status)
+      if resp.status < httplib.INTERNAL_SERVER_ERROR:
+        return resp
+
+
+  @classmethod
+  def _get_token_dict(cls):
+    if cls._token_cache:
+      # If it expires within 25 seconds, refresh.
+      if cls._token_expiration < time.time() - 25:
+        return cls._token_cache
+
+    resp = cls._get(cls._ACQUIRE_URL, headers=cls._ACQUIRE_HEADERS)
+    if resp.status != httplib.OK:
+      return None
+    cls._token_cache = json.load(resp)
+    cls._token_expiration = cls._token_cache['expires_in'] + time.time()
+    return cls._token_cache
+
+  def get_auth_header(self, _host):
+    token_dict = self._get_token_dict()
+    if not token_dict:
+      return None
+    return '%(token_type)s %(access_token)s' % token_dict
+
+
+
 def CreateHttpConn(host, path, reqtype='GET', headers=None, body=None):
   """Opens an https connection to a gerrit service, and sends a request."""
   headers = headers or {}
   bare_host = host.partition(':')[0]
-  auth = NETRC.authenticators(bare_host)
 
+  auth = Authenticator.get().get_auth_header(bare_host)
   if auth:
-    headers.setdefault('Authorization', 'Basic %s' % (
-        base64.b64encode('%s:%s' % (auth[0], auth[2]))))
+    headers.setdefault('Authorization', auth)
   else:
-    LOGGER.debug('No authorization found in netrc for %s.' % bare_host)
+    LOGGER.debug('No authorization found for %s.' % bare_host)
 
   if 'Authorization' in headers and not path.startswith('a/'):
     url = '/a/%s' % path
@@ -313,6 +483,21 @@ def GetChangeDetail(host, change, o_params=None):
   return ReadHttpJsonResponse(CreateHttpConn(host, path))
 
 
+def GetChangeDescriptionFromGitiles(url, revision):
+  """Query Gitiles for actual commit message for a given url and ref.
+
+  url must be obtained from call to GetChangeDetail for a specific
+  revision (patchset) under 'fetch' key.
+  """
+  parsed = urlparse.urlparse(url)
+  path = '%s/+/%s?format=json' % (parsed.path, revision)
+  # Note: Gerrit instances that Chrome infrastructure uses thus far have all
+  # enabled Gitiles, which allowes us to execute this call. This isn't true for
+  # all Gerrit instances out there. Thus, if line below fails, consider adding a
+  # fallback onto actually fetching ref from remote using pure git.
+  return ReadHttpJsonResponse(CreateHttpConn(parsed.netloc, path))['message']
+
+
 def GetChangeCurrentRevision(host, change):
   """Get information about the latest revision for a given change."""
   return QueryChanges(host, {}, change, o_params=('CURRENT_REVISION',))
@@ -339,7 +524,7 @@ def GetChangeReview(host, change, revision=None):
 def AbandonChange(host, change, msg=''):
   """Abandon a gerrit change."""
   path = 'changes/%s/abandon' % change
-  body = {'message': msg} if msg else None
+  body = {'message': msg} if msg else {}
   conn = CreateHttpConn(host, path, reqtype='POST', body=body)
   return ReadHttpJsonResponse(conn, ignore_404=False)
 
@@ -347,7 +532,7 @@ def AbandonChange(host, change, msg=''):
 def RestoreChange(host, change, msg=''):
   """Restore a previously abandoned change."""
   path = 'changes/%s/restore' % change
-  body = {'message': msg} if msg else None
+  body = {'message': msg} if msg else {}
   conn = CreateHttpConn(host, path, reqtype='POST', body=body)
   return ReadHttpJsonResponse(conn, ignore_404=False)
 
@@ -360,6 +545,38 @@ def SubmitChange(host, change, wait_for_merge=True):
   return ReadHttpJsonResponse(conn, ignore_404=False)
 
 
+def SetCommitMessage(host, change, description):
+  """Updates a commit message."""
+  # First, edit the commit message in a draft.
+  path = 'changes/%s/edit:message' % change
+  body = {'message': description}
+  conn = CreateHttpConn(host, path, reqtype='PUT', body=body)
+  try:
+    ReadHttpResponse(conn, ignore_404=False)
+  except GerritError as e:
+    # On success, gerrit returns status 204; anything else is an error.
+    if e.http_status != 204:
+      raise
+  else:
+    raise GerritError(
+        'Unexpectedly received a 200 http status while editing message in '
+        'change %s' % change)
+
+  # And then publish it.
+  path = 'changes/%s/edit:publish' % change
+  conn = CreateHttpConn(host, path, reqtype='POST', body={})
+  try:
+    ReadHttpResponse(conn, ignore_404=False)
+  except GerritError as e:
+    # On success, gerrit returns status 204; anything else is an error.
+    if e.http_status != 204:
+      raise
+  else:
+    raise GerritError(
+        'Unexpectedly received a 200 http status while publishing message '
+        'change in %s' % change)
+
+
 def GetReviewers(host, change):
   """Get information about all reviewers attached to a change."""
   path = 'changes/%s/reviewers' % change