| # Copyright 2016 The Fuchsia Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| from urlparse import urlparse |
| |
| import re |
| |
| from recipe_engine import recipe_api |
| |
| |
| class GitApi(recipe_api.RecipeApi): |
| """GitApi provides support for Git.""" |
| |
| _GIT_HASH_RE = re.compile('[0-9a-f]{40}', re.IGNORECASE) |
| |
| def __init__(self, git_properties, *args, **kwargs): |
| super(GitApi, self).__init__(*args, **kwargs) |
| |
| self._cache_path = git_properties.get('cache_path', 'git') |
| |
| def __call__(self, *args, **kwargs): |
| """Return a git command step.""" |
| name = kwargs.pop('name', 'git ' + args[0]) |
| git_cmd = ['git'] |
| for k, v in sorted(kwargs.pop('config', {}).iteritems()): |
| git_cmd.extend(['-c', '%s=%s' % (k, v)]) |
| |
| return self.m.step(name, git_cmd + list(args), **kwargs) |
| |
| def apply(self, patch, **kwargs): |
| """Applies the specified git patch file.""" |
| return self('apply', patch, **kwargs) |
| |
| def checkout(self, |
| url, |
| path=None, |
| ref=None, |
| recursive=False, |
| submodules=True, |
| submodule_force=False, |
| remote='origin', |
| checkout_file=None, |
| cache=True, |
| **kwargs): |
| """Checkout a given ref and return the checked out revision. |
| |
| Args: |
| url (str): url of remote repo to use as upstream |
| path (Path): directory to clone into |
| ref (str): ref to fetch and check out |
| recursive (bool): whether to recursively fetch submodules or not |
| submodules (bool): whether to sync and update submodules or not |
| submodule_force (bool): whether to update submodules with --force |
| remote (str): name of the remote to use |
| checkout_file (str): optional path to a single file to checkout |
| cache (bool): whether to use the reference cache |
| """ |
| if not path: |
| path = url.rsplit('/', 1)[-1] |
| if path.endswith('.git'): # https://host/foobar.git |
| path = path[:-len('.git')] |
| path = path or path.rsplit('/', 1)[-1] # ssh://host:repo/foobar/.git |
| path = self.m.path['start_dir'].join(path) |
| |
| self.m.file.ensure_directory('makedirs', path) |
| |
| with self.m.context(cwd=path): |
| if self.m.path.exists(path.join('.git')): # pragma: no cover |
| self('config', '--remove-section', 'remote.%s' % remote, **kwargs) |
| else: |
| self('init', **kwargs) |
| self('remote', 'add', remote or 'origin', url) |
| |
| if cache: |
| with self.m.step.nest('cache'): |
| o = urlparse(url) |
| dirname = o.hostname + o.path.replace('-', '--').replace('/', '-') |
| cache_path = self.m.path['cache'].join(self._cache_path, dirname) |
| |
| self.m.file.ensure_directory('makedirs', cache_path) |
| |
| with self.m.context(cwd=cache_path): |
| objects_path = cache_path.join('objects') |
| if self.m.path.exists(objects_path): # pragma: no cover |
| self('config', '--remove-section', 'remote.%s' % remote, **kwargs) |
| else: |
| self('init', '--bare', **kwargs) |
| self( |
| 'config', |
| 'remote.%s.url' % remote or 'origin', |
| url, |
| name='remote set-url', |
| **kwargs) |
| |
| self('config', '--replace-all', 'remote.origin.fetch', |
| '+refs/heads/*:refs/heads/*', r'\+refs/heads/\*:.*', **kwargs) |
| |
| self('fetch', '--prune', '--tags', remote or 'origin', **kwargs) |
| |
| info = path.join('.git', 'objects', 'info') |
| self.m.file.ensure_directory('makedirs object/info', info) |
| self.m.file.write_text('alternates', info.join('alternates'), |
| '%s\n' % objects_path) |
| |
| if not ref: |
| fetch_ref = 'master' |
| checkout_ref = 'FETCH_HEAD' |
| elif self._GIT_HASH_RE.match(ref): |
| fetch_ref = '' |
| checkout_ref = ref |
| elif ref.startswith('refs/heads/'): |
| fetch_ref = ref[len('refs/heads/'):] |
| checkout_ref = 'FETCH_HEAD' |
| else: |
| fetch_ref = ref |
| checkout_ref = 'FETCH_HEAD' |
| fetch_args = [x for x in (remote or 'origin', fetch_ref) if x] |
| if recursive: |
| fetch_args.append('--recurse-submodules') |
| self('fetch', '--tags', *fetch_args, **kwargs) |
| if checkout_file: |
| self('checkout', '-f', checkout_ref, '--', checkout_file, **kwargs) |
| else: |
| self('checkout', '-f', checkout_ref, **kwargs) |
| step_test_data = kwargs.pop( |
| 'step_test_data', lambda: self.m.raw_io.test_api.stream_output( |
| 'deadbeef')) |
| step = self( |
| 'rev-parse', |
| 'HEAD', |
| stdout=self.m.raw_io.output(), |
| step_test_data=step_test_data) |
| sha = step.stdout.strip() |
| self('clean', '-f', '-d', '-x', **kwargs) |
| if submodules: |
| with self.m.step.nest('submodule'): |
| self('submodule', 'sync', name='git submodule sync', **kwargs) |
| submodule_update_args = ['--init'] |
| if recursive: |
| submodule_update_args.append('--recursive') |
| if submodule_force: |
| submodule_update_args.append('--force') |
| self( |
| 'submodule', |
| 'update', |
| *submodule_update_args, |
| name='git submodule update', |
| **kwargs) |
| return sha |
| |
| def checkout_commit(self, commit, **kwargs): |
| """Checks out a gitiles commit. |
| |
| Args (see `checkout()` for others): |
| commit (common_pb2.GitilesCommit): the commit to check out |
| """ |
| url = 'https://%s/%s' % (commit.host, commit.project) |
| return self.checkout(url, ref=commit.id, **kwargs) |
| |
| def checkout_cl(self, cl, path, **kwargs): |
| """Checks out a CL and rebases it on top of master. |
| |
| Args (see `checkout()` for others): |
| cl (common_pb2.GerritChange or None): The CL to check out. |
| """ |
| url = 'https://%s/%s' % (cl.host.replace('-review', ''), cl.project) |
| ref = 'refs/changes/%02d/%d/%d' % (cl.change % 100, cl.change, cl.patchset) |
| with self.m.step.nest('fetch master'): |
| master_ref = self.checkout(url) |
| checkout_result = self.checkout(url, path=path, ref=ref, **kwargs) |
| with self.m.context(cwd=path): |
| self.rebase(master_ref) |
| return checkout_result |
| |
| def commit(self, |
| message, |
| files=(), |
| all_tracked=False, |
| all_files=False, |
| **kwargs): |
| """Runs git commit in the current working directory. |
| Args: |
| message (str): The message to attach to the commit. |
| files (seq[Path]): The set of files containing changes to commit. |
| all_tracked (bool): Stage all tracked files before committing. If True, |
| files must be empty and all_files must be False. |
| all_files (bool): Stage all files (even untracked) before committing. If |
| True, files must be empty and all_tracked must be False. |
| """ |
| if all_tracked: |
| assert not all_files |
| assert not files |
| return self('commit', '-m', message, '-a', **kwargs) |
| elif all_files: |
| assert not files |
| self('add', '-A') |
| return self('commit', '-m', message, **kwargs) |
| return self('commit', '-m', message, *files, **kwargs) |
| |
| def diff(self, ref_base='HEAD', ref=None, patch_file=None, **kwargs): |
| """Runs git diff in the current working directory.""" |
| step_test_data = kwargs.pop( |
| 'step_test_data', lambda: self.m.raw_io.test_api.stream_output(""" |
| diff --git a/recipe_modules/fuchsia/api.py b/recipe_modules/fuchsia/api.py |
| index 429e4612..83925ff3 100644 |
| --- a/recipe_modules/fuchsia/api.py |
| +++ b/recipe_modules/fuchsia/api.py |
| @@ -562,15 +562,6 @@ class FuchsiaApi(recipe_api.RecipeApi): |
| - # arm64 hardware targets have a stable version of Zedboot on their |
| - # recovery partition, we do not want to send the build Zedboot to |
| - # overwrite it. |
| - if build.target == 'arm64' and device_type != 'QEMU': |
| - for image in build.images.keys(): |
| - # Matches both 'zircon-r' and 'zircon-r.signed' |
| - if 'zircon-r' in image: |
| - del build.images[image] |
| """)) |
| if ref is not None: |
| return self( |
| 'diff', |
| ref_base, |
| ref, |
| step_test_data=step_test_data, |
| stdout=self.m.raw_io.output(leak_to=patch_file), |
| **kwargs).stdout.strip() |
| return self( |
| 'diff', |
| ref_base, |
| step_test_data=step_test_data, |
| stdout=self.m.raw_io.output(leak_to=patch_file), |
| **kwargs).stdout.strip() |
| |
| def push(self, ref, remote='origin', dryrun=False, **kwargs): |
| cmd = ['push'] |
| if dryrun: |
| cmd.append('--dry-run') |
| cmd += [remote, ref] |
| return self(*cmd, **kwargs) |
| |
| def rebase(self, *args, **kwargs): |
| """Run rebase with the given arguments. |
| |
| If a StepFailure occurs, abort the rebase and re-raise the error. |
| """ |
| try: |
| self('rebase', *args, **kwargs) |
| except self.m.step.StepFailure: # pragma: no cover |
| self('rebase', '--abort', **kwargs) |
| raise |
| |
| def get_hash(self, commit='HEAD', **kwargs): |
| """Find and return the hash of the given commit.""" |
| step_test_data = kwargs.pop( |
| 'step_test_data', lambda: self.test_api.m.raw_io.stream_output( |
| 'deadbeef')) |
| return self( |
| 'rev-parse', |
| commit, |
| stdout=self.m.raw_io.output(), |
| step_test_data=step_test_data, |
| **kwargs).stdout.strip() |
| |
| def describe(self, |
| commit='HEAD', |
| tags=True, |
| contains=False, |
| exact_match=True, |
| expected_num=None, |
| test_data=None, |
| **kwargs): |
| """ |
| Describe a commit by its tag(s). |
| |
| Args: |
| tags (bool): If True, use any tag in refs/tags namespace. Otherwise, |
| only use annotated tags. |
| contains (bool): If True, find the tag that comes after the given commit. |
| Automatically implies 'tags' flag. |
| exact_match (bool): If True, only output exact tag matches to the given |
| commit. |
| expected_num (int): If specified, raise exception if expected number |
| of tags which describe the given commit is not equal to actual. |
| test_data (func): If specified, overwrite step test data. |
| |
| Returns: |
| list: tag(s) describing the commit. |
| """ |
| if test_data is None: |
| test_data = lambda: self.m.raw_io.test_api.stream_output( |
| 'testtag1\ntesttag2') |
| cmd = ['describe'] |
| if tags is True: |
| cmd.append('--tags') |
| if contains is True: |
| cmd.append('--contains') |
| if exact_match is True: |
| cmd.append('--exact-match') |
| cmd.append(commit) |
| output = self( |
| *cmd, stdout=self.m.raw_io.output(), step_test_data=test_data, |
| **kwargs).stdout.strip() |
| tags = output.split('\n') |
| if expected_num is not None and len(tags) != expected_num: |
| raise self.m.step.StepFailure( |
| 'Expected number of matching tags ({expected_num}) does not match ' |
| 'actual ({actual_num}).'.format( |
| expected_num=expected_num, |
| actual_num=len(tags), |
| )) |
| return tags |
| |
| def get_remote_url(self, name, **kwargs): |
| """Find and return the URL of given remote.""" |
| step_test_data = kwargs.pop( |
| 'step_test_data', lambda: self.test_api.m.raw_io.stream_output( |
| 'https//fuchsia.googlesource.com/fuchsia')) |
| return self( |
| 'config', |
| 'remote.%s.url' % name, |
| stdout=self.m.raw_io.output(), |
| step_test_data=step_test_data, |
| **kwargs).stdout.strip() |
| |
| def get_timestamp(self, commit='HEAD', **kwargs): |
| """Find and return the timestamp of the given commit.""" |
| step_test_data = kwargs.pop( |
| 'step_test_data', lambda: self.m.raw_io.test_api.stream_output( |
| '1473312770')) |
| # TODO(garymm): Use --no-patch instead of -s |
| return self( |
| 'show', |
| commit, |
| '--format=%at', |
| '-s', |
| step_test_data=step_test_data, |
| stdout=self.m.raw_io.output(), |
| **kwargs).stdout.strip() |
| |
| def get_commit_message(self, commit='HEAD', oneline=False, **kwargs): |
| """ |
| Returns the message of the given commit. |
| |
| Args: |
| commit (str): git ref to get message for. |
| oneline (bool): shorten message to oneline. |
| """ |
| step_test_data = kwargs.pop( |
| 'step_test_data', lambda: self.m.raw_io.test_api.stream_output( |
| '[foo] bar\nbaz\n')) |
| args = [ |
| 'show', |
| commit, |
| '--format=%B', |
| '--no-patch', |
| ] |
| if oneline is True: |
| args.append('--oneline') |
| step = self( |
| *args, |
| step_test_data=step_test_data, |
| stdout=self.m.raw_io.output(), |
| **kwargs) |
| commit_msg = step.stdout.strip() |
| step.presentation.logs['commit message'] = commit_msg.splitlines() |
| return commit_msg |
| |
| def get_changed_files(self, commit='HEAD', **kwargs): |
| """Return a list of files changed/added/removed in a CL. |
| |
| Args: |
| commit (str): git ref to get the files for. |
| """ |
| test_data = kwargs.pop('test_data', 'foo/bar/baz\0foo/baz\0') |
| if isinstance(test_data, (list, tuple)): |
| test_data = ''.join('{}\0'.format(x) for x in test_data) |
| |
| step_test_data = lambda: self.m.raw_io.test_api.stream_output(test_data) |
| |
| args = [ |
| 'diff-tree', |
| '--no-commit-id', |
| '--name-only', |
| '-r', # Recurse into subrepos. |
| 'HEAD', |
| '-z', # Separate results with nuls. |
| ] |
| |
| step = self( |
| *args, |
| step_test_data=step_test_data, |
| stdout=self.m.raw_io.output(), |
| **kwargs) |
| files = step.stdout.strip('\0').split('\0') |
| step.presentation.logs['files'] = files |
| return files |
| |
| def snap_branch(self, |
| url, |
| snap_ref, |
| branch, |
| message, |
| tmp_branch='tmp_branch', |
| path=None, |
| checkout=True, |
| push=False): |
| """ |
| Snap a target branch to specified ref, i.e. overwrite target |
| branch to be equal to specified ref without losing previous history. |
| |
| Args: |
| url (str): url of remote repo to use as upstream. |
| snap_ref (str): commit hash ref to snap to. |
| branch (str): target branch to apply snap. |
| message (str): snap commit message. |
| tmp_branch (str): temporary branch name. |
| path (Path): directory to checkout in. |
| checkout (bool): if False, use the existing checkout at path. |
| push (bool): push snap to target branch. |
| """ |
| assert not (not checkout and not path), \ |
| 'Cannot attempt snap with neither a checkout nor a path.' |
| with self.m.step.nest('snap branch'): |
| path = path or self.m.path.mkdtemp() |
| with self.m.context(cwd=path): |
| if checkout: |
| self.checkout( |
| url=url, |
| ref=branch, |
| path=path, |
| ) |
| # If branch HEAD is already at snap ref, no further action needed. |
| if self.get_hash() == snap_ref: |
| return |
| |
| remote_branch = 'origin/{branch}'.format(branch=branch) |
| # Create temporary branch off target branch. |
| self('checkout', '-b', tmp_branch, remote_branch) |
| # Reset temporary branch to snap ref, preserving history. |
| self('reset', '--hard', snap_ref) |
| self('merge', '--strategy', 'ours', remote_branch, '--message', message) |
| if push: |
| # Push snapped temporary branch to target branch. |
| self.push('{tmp_branch}:refs/heads/{branch}'.format( |
| tmp_branch=tmp_branch, |
| branch=branch, |
| )) |
| |
| def get_remote_branch_head(self, url, branch): |
| """ |
| Get remote branch head. |
| If the branch does not exist remotely, return empty string. |
| |
| Args: |
| url (str): remote repository URL. |
| branch (str): branch name. |
| |
| Returns: |
| str: HEAD commit SHA1 if it exists, otherwise empty string. |
| """ |
| head_output = self( |
| 'ls-remote', |
| '--heads', |
| url, |
| branch, |
| stdout=self.m.raw_io.output(), |
| step_test_data=lambda: self.m.raw_io.test_api.stream_output( |
| 'h3ll0 {branch}'.format(branch=branch)), |
| ).stdout.strip() |
| # Parse out the commit SHA1. |
| return head_output.split()[0] if head_output else head_output |
| |
| def get_remote_tag(self, url, tag): |
| """ |
| Get remote tag commit. |
| If the tag does not exist remotely, return empty string. |
| |
| Args: |
| url (str): remote repository URL. |
| tag (str): git tag. |
| |
| Returns: |
| str: tag's commit SHA1 if it exists, otherwise empty string. |
| """ |
| tag_output = self( |
| 'ls-remote', |
| '--tags', |
| url, |
| tag, |
| stdout=self.m.raw_io.output(), |
| step_test_data=lambda: self.m.raw_io.test_api.stream_output( |
| 'tagcommit {tag}'.format(tag=tag)), |
| ).stdout.strip() |
| # Parse out the commit SHA1. |
| return tag_output.split()[0] if tag_output else tag_output |
