libv8 6.7.288.46.1 → 7.3.492.27.0beta1

data/vendor/depot_tools/gerrit_client.py

@@ -88,6 +88,19 @@ def CMDchanges(parser, args):
   write_result(result, opt)
 
 
+@subcommand.usage('')
+def CMDabandon(parser, args):
+  parser.add_option('-c', '--change', type=int, help='change number')
+  parser.add_option('-m', '--message', default='', help='reason for abandoning')
+
+  (opt, args) = parser.parse_args(args)
+  result = gerrit_util.AbandonChange(
+      urlparse.urlparse(opt.host).netloc,
+      opt.change, opt.message)
+  logging.info(result)
+  write_result(result, opt)
+
+
 class OptionParser(optparse.OptionParser):
   """Creates the option parse and add --verbose support."""
   def __init__(self, *args, **kwargs):

data/vendor/depot_tools/gerrit_util.py

@@ -16,6 +16,7 @@ import json
 import logging
 import netrc
 import os
+import random
 import re
 import socket
 import stat
@@ -25,16 +26,20 @@ import time
 import urllib
 import urlparse
 from cStringIO import StringIO
+from multiprocessing.pool import ThreadPool
 
 import auth
 import gclient_utils
+import metrics
+import metrics_utils
 import subprocess2
 from third_party import httplib2
 
 LOGGER = logging.getLogger()
-# With a starting sleep time of 1 second, 2^n exponential backoff, and six
-# total tries, the sleep time between the first and last tries will be 31s.
-TRY_LIMIT = 6
+# With a starting sleep time of 1.5 seconds, 2^n exponential backoff, and seven
+# total tries, the sleep time between the first and last tries will be 94.5 sec.
+# TODO(crbug.com/881860): Lower this when crbug.com/877717 is fixed.
+TRY_LIMIT = 7
 
 
 # Controls the transport protocol used to communicate with gerrit.
@@ -102,9 +107,27 @@ class CookiesAuthenticator(Authenticator):
   Expected case for developer workstations.
   """
 
+  _EMPTY = object()
+
   def __init__(self):
-    self.netrc = self._get_netrc()
-    self.gitcookies = self._get_gitcookies()
+    # Credentials will be loaded lazily on first use. This ensures Authenticator
+    # get() can always construct an authenticator, even if something is broken.
+    # This allows 'creds-check' to proceed to actually checking creds later,
+    # rigorously (instead of blowing up with a cryptic error if they are wrong).
+    self._netrc = self._EMPTY
+    self._gitcookies = self._EMPTY
+
+  @property
+  def netrc(self):
+    if self._netrc is self._EMPTY:
+      self._netrc = self._get_netrc()
+    return self._netrc
+
+  @property
+  def gitcookies(self):
+    if self._gitcookies is self._EMPTY:
+      self._gitcookies = self._get_gitcookies()
+    return self._gitcookies
 
   @classmethod
   def get_new_password_url(cls, host):
@@ -117,6 +140,10 @@ class CookiesAuthenticator(Authenticator):
 
   @classmethod
   def get_new_password_message(cls, host):
+    if host is None:
+      return ('Git host for gerrit upload is unknown. Check your remote '
+              'and the branch your branch is tracking. This tool assumes '
+              'that you are using a git server at *.googlesource.com.')
     assert not host.startswith('http')
     # Assume *.googlesource.com pattern.
     parts = host.split('.')
@@ -134,16 +161,17 @@ class CookiesAuthenticator(Authenticator):
   def _get_netrc(cls):
     # Buffer the '.netrc' path. Use an empty file if it doesn't exist.
     path = cls.get_netrc_path()
-    content = ''
-    if os.path.exists(path):
-      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)
-      with open(path) as fd:
-        content = fd.read()
+    if not os.path.exists(path):
+      return netrc.netrc(os.devnull)
+
+    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)
+    with open(path) as fd:
+      content = fd.read()
 
     # Load the '.netrc' file. We strip comments from it because processing them
     # can trigger a bug in Windows. See crbug.com/664664.
@@ -198,11 +226,13 @@ class CookiesAuthenticator(Authenticator):
             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)
+            if value.startswith('git-'):
+              login, secret_token = value.split('=', 1)
+              gitcookies[domain] = (login, secret_token)
+            else:
+              gitcookies[domain] = ('', value)
         except (IndexError, ValueError, TypeError) as exc:
           LOGGER.warning(exc)
-
     return gitcookies
 
   def _get_auth_for_host(self, host):
@@ -214,7 +244,10 @@ class CookiesAuthenticator(Authenticator):
   def get_auth_header(self, host):
     a = self._get_auth_for_host(host)
     if a:
-      return 'Basic %s' % (base64.b64encode('%s:%s' % (a[0], a[2])))
+      if a[0]:
+        return 'Basic %s' % (base64.b64encode('%s:%s' % (a[0], a[2])))
+      else:
+        return 'Bearer %s' % a[2]
     return None
 
   def get_auth_email(self, host):
@@ -359,6 +392,8 @@ def CreateHttpConn(host, path, reqtype='GET', headers=None, body=None):
     if body:
       LOGGER.debug(body)
   conn = GetConnectionObject()
+  # HACK: httplib.Http has no such attribute; we store req_host here for later
+  # use in ReadHttpResponse.
   conn.req_host = host
   conn.req_params = {
       'uri': urlparse.urljoin('%s://%s' % (GERRIT_PROTOCOL, host), url),
@@ -378,10 +413,18 @@ def ReadHttpResponse(conn, accept_statuses=frozenset([200])):
                      Common additions include 204, 400, and 404.
   Returns: A string buffer containing the connection's reply.
   """
-  sleep_time = 1
+  sleep_time = 1.5
   for idx in range(TRY_LIMIT):
+    before_response = time.time()
     response, contents = conn.request(**conn.req_params)
 
+    response_time = time.time() - before_response
+    metrics.collector.add_repeated(
+        'http_requests',
+        metrics_utils.extract_http_metrics(
+            conn.req_params['uri'], conn.req_params['method'], response.status,
+            response_time))
+
     # Check if this is an authentication issue.
     www_authenticate = response.get('www-authenticate')
     if (response.status in (httplib.UNAUTHORIZED, httplib.FOUND) and
@@ -413,11 +456,23 @@ def ReadHttpResponse(conn, accept_statuses=frozenset([200])):
                 conn.req_host, conn.req_params['method'],
                 conn.req_params['uri'],
                 http_version, http_version, response.status, response.reason)
+    if response.status == 404:
+      # TODO(crbug/881860): remove this hack.
+      # HACK: try different Gerrit mirror as a workaround for potentially
+      # out-of-date mirror hit through default routing.
+      if conn.req_host == 'chromium-review.googlesource.com':
+        conn.req_params['uri'] = _UseGerritMirror(
+            conn.req_params['uri'], 'chromium-review.googlesource.com')
+        # And don't increase sleep_time in this case, since we suspect we've
+        # just asked wrong git mirror before.
+        sleep_time /= 2.0
+
     if TRY_LIMIT - idx > 1:
       LOGGER.info('Will retry in %d seconds (%d more times)...',
                   sleep_time, TRY_LIMIT - idx - 1)
       time.sleep(sleep_time)
       sleep_time = sleep_time * 2
+  # end of retries loop
   if response.status not in accept_statuses:
     if response.status in (401, 403):
       print('Your Gerrit credentials might be misconfigured. Try: \n'
@@ -562,6 +617,18 @@ def GetGerritFetchUrl(host):
   return '%s://%s/' % (GERRIT_PROTOCOL, host)
 
 
+def GetCodeReviewTbrScore(host, project):
+  """Given a gerrit host name and project, return the Code-Review score for TBR.
+  """
+  conn = CreateHttpConn(host, '/projects/%s' % urllib.quote(project, safe=''))
+  project = ReadHttpJsonResponse(conn)
+  if ('labels' not in project
+      or 'Code-Review' not in project['labels']
+      or 'values' not in project['labels']['Code-Review']):
+    return 1
+  return max([int(x) for x in project['labels']['Code-Review']['values']])
+
+
 def GetChangePageUrl(host, change_number):
   """Given a gerrit host name and change number, return change page url."""
   return '%s://%s/#/c/%d/' % (GERRIT_PROTOCOL, host, change_number)
@@ -621,6 +688,12 @@ def GetChangeComments(host, change):
   return ReadHttpJsonResponse(CreateHttpConn(host, path))
 
 
+def GetChangeRobotComments(host, change):
+  """Get the line- and file-level robot comments on a change."""
+  path = 'changes/%s/robotcomments' % change
+  return ReadHttpJsonResponse(CreateHttpConn(host, path))
+
+
 def AbandonChange(host, change, msg=''):
   """Abandon a gerrit change."""
   path = 'changes/%s/abandon' % change
@@ -863,11 +936,34 @@ def GetAccountDetails(host, account_id='self'):
 
   Documentation:
     https://gerrit-review.googlesource.com/Documentation/rest-api-accounts.html#get-account
+
+  Returns None if account is not found (i.e., Gerrit returned 404).
   """
-  if account_id != 'self':
-    account_id = int(account_id)
   conn = CreateHttpConn(host, '/accounts/%s' % account_id)
-  return ReadHttpJsonResponse(conn)
+  return ReadHttpJsonResponse(conn, accept_statuses=[200, 404])
+
+
+def ValidAccounts(host, accounts, max_threads=10):
+  """Returns a mapping from valid account to its details.
+
+  Invalid accounts, either not existing or without unique match,
+  are not present as returned dictionary keys.
+  """
+  assert not isinstance(accounts, basestring), type(accounts)
+  accounts = list(set(accounts))
+  if not accounts:
+    return {}
+  def get_one(account):
+    try:
+      return account, GetAccountDetails(host, account)
+    except GerritError:
+      return None, None
+  valid = {}
+  with contextlib.closing(ThreadPool(min(max_threads, len(accounts)))) as pool:
+    for account, details in pool.map(get_one, accounts):
+      if account and details:
+        valid[account] = details
+  return valid
 
 
 def PercentEncodeForGitRef(original):
@@ -899,3 +995,42 @@ def tempdir():
   finally:
     if tdir:
       gclient_utils.rmtree(tdir)
+
+
+def ChangeIdentifier(project, change_number):
+  """Returns change identifier "project~number" suitable for |change| arg of
+  this module API.
+
+  Such format is allows for more efficient Gerrit routing of HTTP requests,
+  comparing to specifying just change_number.
+  """
+  assert int(change_number)
+  return '%s~%s' % (urllib.quote(project, safe=''), change_number)
+
+
+# TODO(crbug/881860): remove this hack.
+_GERRIT_MIRROR_PREFIXES = ['us1', 'us2', 'us3', 'eu1']
+assert all(3 == len(p) for p in _GERRIT_MIRROR_PREFIXES)
+
+
+def _UseGerritMirror(url, host):
+  """Returns new url which uses randomly selected mirror for a gerrit host.
+
+  url's host should be for a given host or a result of prior call to this
+  function.
+
+  Assumes url has a single occurence of the host substring.
+  """
+  assert host in url
+  suffix = '-mirror-' + host
+  prefixes = set(_GERRIT_MIRROR_PREFIXES)
+  prefix_len = len(_GERRIT_MIRROR_PREFIXES[0])
+  st = url.find(suffix)
+  if st == -1:
+    actual_host = host
+  else:
+    # Already uses some mirror.
+    assert st >= prefix_len, (uri, host, st, prefix_len)
+    prefixes.remove(url[st-prefix_len:st])
+    actual_host = url[st-prefix_len:st+len(suffix)]
+  return url.replace(actual_host, random.choice(list(prefixes)) + suffix)

data/vendor/depot_tools/git-nav-upstream

@@ -3,4 +3,4 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-git checkout '@{u}'
+git checkout "$(git rev-parse  --abbrev-ref "@{u}")"

data/vendor/depot_tools/git_cache.py

@@ -6,6 +6,7 @@
 """A git command for managing a local cache of git repositories."""
 
 from __future__ import print_function
+
 import contextlib
 import errno
 import logging
@@ -17,7 +18,12 @@ import threading
 import time
 import subprocess
 import sys
-import urlparse
+
+try:
+  import urlparse
+except ImportError:  # For Py3 compatibility
+  import urllib.parse as urlparse
+
 import zipfile
 
 from download_from_google_storage import Gsutil
@@ -195,6 +201,11 @@ class Mirror(object):
     os.path.dirname(os.path.abspath(__file__)), 'gsutil.py')
   cachepath_lock = threading.Lock()
 
+  UNSET_CACHEPATH = object()
+
+  # Used for tests
+  _GIT_CONFIG_LOCATION = []
+
   @staticmethod
   def parse_fetch_spec(spec):
     """Parses and canonicalizes a fetch spec.
@@ -234,9 +245,14 @@ class Mirror(object):
 
   @property
   def bootstrap_bucket(self):
+    b = os.getenv('OVERRIDE_BOOTSTRAP_BUCKET')
+    if b:
+      return b
     u = urlparse.urlparse(self.url)
     if u.netloc == 'chromium.googlesource.com':
       return 'chromium-git-cache'
+    # TODO(tandrii): delete once LUCI migration is completed.
+    # Only public hosts will be supported going forward.
     elif u.netloc == 'chrome-internal.googlesource.com':
       return 'chrome-git-cache'
     # Not recognized.
@@ -253,6 +269,10 @@ class Mirror(object):
     norm_url = parsed.netloc + parsed.path
     if norm_url.endswith('.git'):
       norm_url = norm_url[:-len('.git')]
+
+    # Use the same dir for authenticated URLs and unauthenticated URLs.
+    norm_url = norm_url.replace('googlesource.com/a/', 'googlesource.com/')
+
     return norm_url.replace('-', '--').replace('/', '-').lower()
 
   @staticmethod
@@ -272,14 +292,18 @@ class Mirror(object):
       if not hasattr(cls, 'cachepath'):
         try:
           cachepath = subprocess.check_output(
-              [cls.git_exe, 'config', '--global', 'cache.cachepath']).strip()
+              [cls.git_exe, 'config'] +
+              cls._GIT_CONFIG_LOCATION +
+              ['cache.cachepath']).strip()
         except subprocess.CalledProcessError:
-          cachepath = None
-        if not cachepath:
-          raise RuntimeError(
-              'No global cache.cachepath git configuration found.')
+          cachepath = os.environ.get('GIT_CACHE_PATH', cls.UNSET_CACHEPATH)
         setattr(cls, 'cachepath', cachepath)
-      return getattr(cls, 'cachepath')
+
+      ret = getattr(cls, 'cachepath')
+      if ret is cls.UNSET_CACHEPATH:
+        raise RuntimeError('No cache.cachepath git configuration or '
+                           '$GIT_CACHE_PATH is set.')
+      return ret
 
   def Rename(self, src, dst):
     # This is somehow racy on Windows.
@@ -302,10 +326,19 @@ class Mirror(object):
     self.print('running "git %s" in "%s"' % (' '.join(cmd), cwd))
     gclient_utils.CheckCallAndFilter([self.git_exe] + cmd, **kwargs)
 
-  def config(self, cwd=None):
+  def config(self, cwd=None, reset_fetch_config=False):
     if cwd is None:
       cwd = self.mirror_path
 
+    if reset_fetch_config:
+      try:
+        self.RunGit(['config', '--unset-all', 'remote.origin.fetch'], cwd=cwd)
+      except subprocess.CalledProcessError as e:
+        # If exit code was 5, it means we attempted to unset a config that
+        # didn't exist. Ignore it.
+        if e.returncode != 5:
+          raise
+
     # Don't run git-gc in a daemon.  Bad things can happen if it gets killed.
     try:
       self.RunGit(['config', 'gc.autodetach', '0'], cwd=cwd)
@@ -339,21 +372,34 @@ class Mirror(object):
     """
     if not self.bootstrap_bucket:
       return False
-    python_fallback = False
-    if (sys.platform.startswith('win') and
-        not gclient_utils.FindExecutable('7z')):
-      python_fallback = True
-    elif sys.platform.startswith('darwin'):
-      # The OSX version of unzip doesn't support zip64.
-      python_fallback = True
-    elif not gclient_utils.FindExecutable('unzip'):
-      python_fallback = True
+    python_fallback = (
+        (sys.platform.startswith('win') and
+          not gclient_utils.FindExecutable('7z')) or
+        (not gclient_utils.FindExecutable('unzip')) or
+        ('ZIP64_SUPPORT' not in subprocess.check_output(["unzip", "-v"]))
+    )
 
     gs_folder = 'gs://%s/%s' % (self.bootstrap_bucket, self.basedir)
     gsutil = Gsutil(self.gsutil_exe, boto_path=None)
     # Get the most recent version of the zipfile.
     _, ls_out, ls_err = gsutil.check_call('ls', gs_folder)
-    ls_out_sorted = sorted(ls_out.splitlines())
+
+    def compare_filenames(a, b):
+      # |a| and |b| look like gs://.../.../9999.zip. They both have the same
+      # gs://bootstrap_bucket/basedir/ prefix because they come from the same
+      # `gsutil ls`.
+      # This function only compares the numeral parts before .zip.
+      regex_pattern = r'/(\d+)\.zip$'
+      match_a = re.search(regex_pattern, a)
+      match_b = re.search(regex_pattern, b)
+      if (match_a is not None) and (match_b is not None):
+        num_a = int(match_a.group(1))
+        num_b = int(match_b.group(1))
+        return cmp(num_a, num_b)
+      # If it doesn't match the format, fallback to string comparison.
+      return cmp(a, b)
+
+    ls_out_sorted = sorted(ls_out.splitlines(), cmp=compare_filenames)
     if not ls_out_sorted:
       # This repo is not on Google Storage.
       self.print('No bootstrap file for %s found in %s, stderr:\n  %s' %
@@ -499,8 +545,8 @@ class Mirror(object):
             'Shallow fetch requested, but repo cache already exists.')
     return tempdir
 
-  def _fetch(self, rundir, verbose, depth):
-    self.config(rundir)
+  def _fetch(self, rundir, verbose, depth, reset_fetch_config):
+    self.config(rundir, reset_fetch_config)
     v = []
     d = []
     if verbose:
@@ -522,7 +568,8 @@ class Mirror(object):
         logging.warn('Fetch of %s failed' % spec)
 
   def populate(self, depth=None, shallow=False, bootstrap=False,
-               verbose=False, ignore_lock=False, lock_timeout=0):
+               verbose=False, ignore_lock=False, lock_timeout=0,
+               reset_fetch_config=False):
     assert self.GetCachePath()
     if shallow and not depth:
       depth = 10000
@@ -536,14 +583,14 @@ class Mirror(object):
     try:
       tempdir = self._ensure_bootstrapped(depth, bootstrap)
       rundir = tempdir or self.mirror_path
-      self._fetch(rundir, verbose, depth)
+      self._fetch(rundir, verbose, depth, reset_fetch_config)
     except ClobberNeeded:
       # This is a major failure, we need to clean and force a bootstrap.
       gclient_utils.rmtree(rundir)
       self.print(GIT_CACHE_CORRUPT_MESSAGE)
       tempdir = self._ensure_bootstrapped(depth, bootstrap, force=True)
       assert tempdir
-      self._fetch(tempdir, verbose, depth)
+      self._fetch(tempdir, verbose, depth, reset_fetch_config)
     finally:
       if tempdir:
         if os.path.exists(self.mirror_path):
@@ -684,6 +731,8 @@ def CMDpopulate(parser, args):
   parser.add_option('--ignore_locks', '--ignore-locks',
                     action='store_true',
                     help='Don\'t try to lock repository')
+  parser.add_option('--reset-fetch-config', action='store_true', default=False,
+                    help='Reset the fetch config before populating the cache.')
 
   options, args = parser.parse_args(args)
   if not len(args) == 1:
@@ -697,6 +746,7 @@ def CMDpopulate(parser, args):
       'bootstrap': not options.no_bootstrap,
       'ignore_lock': options.ignore_locks,
       'lock_timeout': options.timeout,
+      'reset_fetch_config': options.reset_fetch_config,
   }
   if options.depth:
     kwargs['depth'] = options.depth
@@ -795,7 +845,10 @@ class OptionParser(optparse.OptionParser):
   def __init__(self, *args, **kwargs):
     optparse.OptionParser.__init__(self, *args, prog='git cache', **kwargs)
     self.add_option('-c', '--cache-dir',
-                    help='Path to the directory containing the cache')
+                    help=(
+                      'Path to the directory containing the caches. Normally '
+                      'deduced from git config cache.cachepath or '
+                      '$GIT_CACHE_PATH.'))
     self.add_option('-v', '--verbose', action='count', default=1,
                     help='Increase verbosity (can be passed multiple times)')
     self.add_option('-q', '--quiet', action='store_true',