libv8 8.4.255.0

data/vendor/depot_tools/recipes/recipe_modules/gitiles/examples/full.py

@@ -0,0 +1,93 @@
+# Copyright 2014 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.
+
+DEPS = [
+    'gitiles',
+    'recipe_engine/json',
+    'recipe_engine/step',
+    'recipe_engine/path',
+    'recipe_engine/properties',
+]
+
+
+def RunSteps(api):
+  url = 'https://chromium.googlesource.com/chromium/src'
+  for ref in api.gitiles.refs(url):
+    _, cursor = api.gitiles.log(url, ref)
+    if cursor:
+      api.gitiles.log(url, ref, limit=10, cursor=cursor)
+  api.gitiles.commit_log(url, api.properties['commit_log_hash'])
+
+  data = api.gitiles.download_file(url, 'OWNERS', attempts=5)
+  assert data == 'foobar'
+  data = api.gitiles.download_file(url, 'NONEXISTENT', attempts=1,
+                                   accept_statuses=[404])
+
+  api.gitiles.download_archive(url, api.path['start_dir'].join('archive'))
+
+  try:
+    api.gitiles.download_archive(url, api.path['start_dir'].join('archive2'))
+    assert False  # pragma: no cover
+  except api.step.StepFailure as ex:
+    assert '/root' in ex.gitiles_skipped_files
+
+
+def GenTests(api):
+  yield (
+      api.test('basic')
+      + api.properties(
+          commit_log_hash=api.gitiles.make_hash('commit'),
+      )
+      + api.step_data('refs', api.gitiles.make_refs_test_data(
+          'HEAD',
+          'refs/heads/A',
+          'refs/tags/B',
+      ))
+      + api.step_data(
+          'gitiles log: HEAD',
+          api.gitiles.make_log_test_data('HEAD', cursor='deadbeaf'),
+      )
+      + api.step_data(
+          'gitiles log: HEAD from deadbeaf',
+          api.gitiles.make_log_test_data('HEAD'),
+      )
+      + api.step_data(
+          'gitiles log: refs/heads/A',
+          api.gitiles.make_log_test_data('A'),
+      )
+      + api.step_data(
+          'gitiles log: refs/tags/B',
+          api.gitiles.make_log_test_data('B')
+      )
+      + api.step_data(
+          'commit log: %s' % (api.gitiles.make_hash('commit')),
+          api.gitiles.make_commit_test_data('commit', 'C', new_files=[
+              'foo/bar',
+              'baz/qux',
+          ])
+      )
+      + api.step_data(
+          'fetch master:OWNERS',
+          api.gitiles.make_encoded_file('foobar')
+      )
+      + api.step_data(
+          'fetch master:NONEXISTENT',
+          api.json.output({'value': None})
+      )
+      + api.step_data(
+          ('download https://chromium.googlesource.com/chromium/src @ '
+           'refs/heads/master (2)'),
+        api.json.output({
+          'extracted': {
+            'filecount': 10,
+            'bytes': 14925,
+          },
+          'skipped': {
+            'filecount': 4,
+            'bytes': 7192345,
+            'names': ['/root', '../relative', 'sneaky/../../relative'],
+          },
+        })
+      )
+  )

data/vendor/depot_tools/recipes/recipe_modules/gitiles/resources/gerrit_client.py

@@ -0,0 +1,251 @@
+#!/usr/bin/python
+# Copyright 2014 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.
+
+"""Simple client for the Gerrit REST API.
+
+Example usage:
+  ./gerrit_client.py -j /tmp/out.json -f json \
+    -u https://chromium.googlesource.com/chromium/src/+log
+"""
+
+import argparse
+import json
+import logging
+import os
+import sys
+import tarfile
+import time
+import urllib
+import urlparse
+
+DEPOT_TOOLS = os.path.abspath(
+    os.path.join(os.path.dirname(__file__), os.pardir, os.pardir, os.pardir,
+                 os.pardir))
+sys.path.insert(0, DEPOT_TOOLS)
+
+from gerrit_util import CreateHttpConn, ReadHttpResponse, ReadHttpJsonResponse
+
+
+def reparse_url(parsed_url, query_params):
+  return urlparse.ParseResult(
+      scheme=parsed_url.scheme,
+      netloc=parsed_url.netloc,
+      path=parsed_url.path,
+      params=parsed_url.params,
+      fragment=parsed_url.fragment,
+      query=urllib.urlencode(query_params, doseq=True))
+
+
+def gitiles_get(parsed_url, handler, attempts):
+  # This insanity is due to CreateHttpConn interface :(
+  host = parsed_url.netloc
+  path = parsed_url.path
+  if parsed_url.query:
+    path += '?%s' % (parsed_url.query, )
+
+  retry_delay_seconds = 1
+  attempt = 1
+  while True:
+    try:
+      return handler(CreateHttpConn(host, path))
+    except Exception as e:
+      if attempt >= attempts:
+        raise
+      logging.exception('Failed to perform Gitiles operation: %s', e)
+
+    # Retry from previous loop.
+    logging.error('Sleeping %d seconds before retry (%d/%d)...',
+                  retry_delay_seconds, attempt, attempts)
+    time.sleep(retry_delay_seconds)
+    retry_delay_seconds *= 2
+    attempt += 1
+
+
+def fetch_log_with_paging(query_params, limit, fetch):
+  """Fetches log, possibly requesting multiple pages to do so.
+
+  Args:
+    query_params (dict): Parameters to use in the request.
+    limit (int): Page size.
+    fetch (function): Function to use to make the requests.
+
+  Returns:
+    Dict with key "log", whose value is a list of commits.
+  """
+  # Log api returns {'log': [list of commits], 'next': hash}.
+  last_result = fetch(query_params)
+  commits = last_result['log']
+  while last_result.get('next') and len(commits) < limit:
+    query_params['s'] = last_result.get('next')
+    last_result = fetch(query_params)
+    # The first commit in `last_result` is not necessarily the parent of the
+    # last commit in result so far!  This is because log command can be done on
+    # one file object, for example:
+    #   https://gerrit.googlesource.com/gitiles/+log/1c21279f337da8130/COPYING
+    # Even when getting log for the whole repository, there could be merge
+    # commits.
+    commits.extend(last_result['log'])
+  # Use 'next' field (if any) from `last_result`, but commits aggregated
+  # from all the results. This essentially imitates paging with at least
+  # `limit` page size.
+  last_result['log'] = commits
+  logging.debug(
+      'fetched %d commits, next: %s.', len(commits),
+      last_result.get('next'))
+  return last_result
+
+
+def main(arguments):
+  parser = create_argparser()
+  args = parser.parse_args(arguments)
+
+  if args.extract_to and args.format != "archive":
+    parser.error('--extract-to requires --format=archive')
+  if not args.extract_to and args.format == "archive":
+    parser.error('--format=archive requires --extract-to')
+
+  if args.extract_to:
+    # make sure it is absolute and ends with '/'
+    args.extract_to = os.path.join(os.path.abspath(args.extract_to), '')
+    os.makedirs(args.extract_to)
+
+  parsed_url = urlparse.urlparse(args.url)
+  if not parsed_url.scheme.startswith('http'):
+    parser.error('Invalid URI scheme (expected http or https): %s' % args.url)
+
+  query_params = {}
+  if parsed_url.query:
+    query_params.update(urlparse.parse_qs(parsed_url.query))
+  # Force the format specified on command-line.
+  if query_params.get('format'):
+    parser.error('URL must not contain format; use --format command line flag '
+                 'instead.')
+  query_params['format'] = args.format
+
+  kwargs = {}
+  accept_statuses = frozenset([int(s) for s in args.accept_statuses.split(',')])
+  if accept_statuses:
+    kwargs['accept_statuses'] = accept_statuses
+
+  # Choose handler.
+  if args.format == 'json':
+    def handler(conn):
+      return ReadHttpJsonResponse(conn, **kwargs)
+  elif args.format == 'text':
+    # Text fetching will pack the text into structured JSON.
+    def handler(conn):
+      # Wrap in a structured JSON for export to recipe module.
+      return {
+        'value': ReadHttpResponse(conn, **kwargs).read() or None,
+      }
+  elif args.format == 'archive':
+    # Archive fetching hooks result to tarfile extraction. This implementation
+    # is able to do a streaming extraction operation without having to buffer
+    # the entire tarfile.
+    def handler(conn):
+      ret = {
+        'extracted': {
+          'filecount': 0,
+          'bytes': 0,
+        },
+        'skipped': {
+          'filecount': 0,
+          'bytes': 0,
+          'names': [],
+        }
+      }
+      fileobj = ReadHttpResponse(conn, **kwargs)
+      with tarfile.open(mode='r|*', fileobj=fileobj) as tf:
+        # monkeypatch the TarFile object to allow printing messages and
+        # collecting stats for each extracted file. extractall makes a single
+        # linear pass over the tarfile, which is compatible with
+        # ReadHttpResponse; other naive implementations (such as `getmembers`)
+        # do random access over the file and would require buffering the whole
+        # thing (!!).
+        em = tf._extract_member
+        def _extract_member(tarinfo, targetpath):
+          if not os.path.abspath(targetpath).startswith(args.extract_to):
+            print('Skipping %s' % (tarinfo.name,))
+            ret['skipped']['filecount'] += 1
+            ret['skipped']['bytes'] += tarinfo.size
+            ret['skipped']['names'].append(tarinfo.name)
+            return
+          print('Extracting %s' % (tarinfo.name,))
+          ret['extracted']['filecount'] += 1
+          ret['extracted']['bytes'] += tarinfo.size
+          return em(tarinfo, targetpath)
+        tf._extract_member = _extract_member
+        tf.extractall(args.extract_to)
+      return ret
+
+  if args.log_start:
+    query_params['s'] = args.log_start
+
+  def fetch(query_params):
+    parsed_url_with_query = reparse_url(parsed_url, query_params)
+    result = gitiles_get(parsed_url_with_query, handler, args.attempts)
+    if not args.quiet:
+      logging.info('Read from %s: %s', parsed_url_with_query.geturl(), result)
+    return result
+
+  if args.log_limit:
+    if args.format != 'json':
+      parser.error('--log-limit works with json format only')
+    result = fetch_log_with_paging(query_params, args.log_limit, fetch)
+  else:
+    # Either not a log request, or don't care about paging.
+    # So, just return whatever is fetched the first time.
+    result = fetch(query_params)
+
+  with open(args.json_file, 'w') as json_file:
+    json.dump(result, json_file)
+  return 0
+
+
+def create_argparser():
+  parser = argparse.ArgumentParser()
+  parser.add_argument(
+      '-j', '--json-file',
+      help='Path to json file for output.')
+  parser.add_argument(
+      '--extract-to',
+      help='Local path to extract archive url. Must not exist.')
+  parser.add_argument(
+      '-f', '--format', required=True, choices=('json', 'text', 'archive'))
+  parser.add_argument(
+      '-u', '--url', required=True,
+      help='Url of gitiles. For example, '
+           'https://chromium.googlesource.com/chromium/src/+refs. '
+           'Insert a/ after domain for authenticated access.')
+  parser.add_argument(
+      '-a', '--attempts', type=int, default=1,
+      help='The number of attempts to make (with exponential backoff) before '
+           'failing. If several requests are to be made, applies per each '
+           'request separately.')
+  parser.add_argument(
+      '-q', '--quiet', action='store_true',
+      help='Suppress file contents logging output.')
+  parser.add_argument(
+      '--log-limit', type=int, default=None,
+      help='Follow gitiles pages to fetch at least this many commits. By '
+           'default, first page with unspecified number of commits is fetched. '
+           'Only for https://<hostname>/<repo>/+log/... gitiles request.')
+  parser.add_argument(
+      '--log-start',
+      help='If given, continue fetching log by paging from this commit hash. '
+           'This value can be typically be taken from json result of previous '
+           'call to log, which returns next page start commit as "next" key. '
+           'Only for https://<hostname>/<repo>/+log/... gitiles request.')
+  parser.add_argument(
+      '--accept-statuses', type=str, default='200',
+      help='Comma-separated list of Status codes to accept as "successful" '
+           'HTTP responses.')
+  return parser
+
+
+if __name__ == '__main__':
+  logging.basicConfig()
+  logging.getLogger().setLevel(logging.INFO)
+  sys.exit(main(sys.argv[1:]))

data/vendor/depot_tools/recipes/recipe_modules/gitiles/test_api.py

@@ -0,0 +1,95 @@
+# Copyright 2014 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.
+
+import base64
+import hashlib
+
+from recipe_engine import recipe_test_api
+
+
+class GitilesTestApi(recipe_test_api.RecipeTestApi):
+
+  def _make_gitiles_response_json(self, data):
+    return self.m.json.output(data)
+
+  def make_refs_test_data(self, *refs):
+    return self._make_gitiles_response_json({ref: None for ref in refs})
+
+  def make_log_test_data(self, s, n=3, cursor=None):
+    result = {
+        'log': [
+            self.make_commit_gitiles_dict(
+                commit='fake %s hash %d' % (s, i),
+                msg='fake %s msg %d' % (s, i),
+                new_files=['%s.py' % (chr(i + ord('a')))],
+                email='fake_%s@fake_%i.email.com' % (s, i),
+            )
+            for i in xrange(n)
+        ],
+    }
+    if cursor:
+      result['next'] = cursor
+    return self._make_gitiles_response_json(result)
+
+  def make_commit_test_data(self, commit, msg, new_files=None, email=None):
+    """Constructs fake Gitiles commit JSON test output.
+
+    This data structure conforms to the JSON response that Gitiles provides when
+    a commit is queried. For example:
+    https://chromium.googlesource.com/chromium/src/+/875b896a3256c5b86c8725e81489e99ea6c2b4c9?format=json
+
+    Args:
+      commit (str): The fake commit hash.
+      msg (str): The commit message.
+      new_files (list): If not None, a list of filenames (str) to simulate being
+          added in this commit.
+      email: if not None, a proper email with '@' in it to be used for
+          committer's and author's emails.
+    Returns: (raw_io.Output) A simulated Gitiles fetch 'json' output.
+    """
+    commit = self.make_commit_gitiles_dict(commit, msg, new_files, email)
+    return self._make_gitiles_response_json(commit)
+
+  def make_commit_gitiles_dict(self, commit, msg, new_files, email=None):
+    if email is None:
+      name = 'Test Author'
+      email = 'testauthor@fake.chromium.org'
+    else:
+      assert '@' in email
+      name = email.split('@')[0]
+    d = {
+        'commit': self.make_hash(commit),
+        'tree': self.make_hash('tree', commit),
+        'parents': [self.make_hash('parent', commit)],
+        'author': {
+            'name': name,
+            'email': email,
+            'time': 'Mon Jan 01 00:00:00 2015',
+        },
+        'committer': {
+            'name': name,
+            'email': email,
+            'time': 'Mon Jan 01 00:00:00 2015',
+        },
+        'message': msg,
+        'tree_diff': [],
+    }
+    if new_files:
+      d['tree_diff'].extend({
+          'type': 'add',
+          'old_id': 40 * '0',
+          'old_mode': 0,
+          'new_id': self.make_hash('file', f, commit),
+          'new_mode': 33188,
+          'new_path': f,
+      } for f in new_files)
+    return d
+
+  def make_hash(self, *bases):
+    return hashlib.sha1(':'.join(bases)).hexdigest()
+
+  def make_encoded_file(self, data):
+    return self.m.json.output({
+        'value': base64.b64encode(data),
+    })

data/vendor/depot_tools/recipes/recipe_modules/gitiles/tests/parse_repo_url.expected/basic.json

@@ -0,0 +1,5 @@
+[
+  {
+    "name": "$result"
+  }
+]

data/vendor/depot_tools/recipes/recipe_modules/gitiles/tests/parse_repo_url.py

@@ -0,0 +1,49 @@
+# Copyright 2018 The LUCI Authors. All rights reserved.
+# Use of this source code is governed under the Apache License, Version 2.0
+# that can be found in the LICENSE file.
+
+DEPS = [
+  'gitiles',
+  'recipe_engine/properties',
+  'recipe_engine/step',
+]
+
+
+def RunSteps(api):
+  valid_urls = [
+    'https://host/path/to/project',
+    'http://host/path/to/project',
+    'https://host/a/path/to/project',
+    'https://host/path/to/project.git',
+    'http://host/a/path/to/project',
+    'host/a/path/to/project',
+  ]
+  for repo_url in valid_urls:
+    host, project = api.gitiles.parse_repo_url(repo_url)
+    assert host == 'host', host
+    assert project == 'path/to/project', project
+
+  invalid_urls = [
+    'https://host/a/path/to/project?a=b',
+    'https://host/path/to/project/+/master',
+  ]
+  for repo_url in invalid_urls:
+    host, project = api.gitiles.parse_repo_url(repo_url)
+    assert host is None
+    assert project is None
+
+  actual = api.gitiles.unparse_repo_url('host', 'path/to/project')
+  expected = 'https://host/path/to/project'
+  assert actual == expected
+
+  actual = api.gitiles.canonicalize_repo_url('http://host/path/to/project')
+  expected = 'https://host/path/to/project'
+  assert actual == expected
+
+  actual = api.gitiles.canonicalize_repo_url('http://unrecognized')
+  expected = 'http://unrecognized'
+  assert actual == expected
+
+
+def GenTests(api):
+  yield api.test('basic')