| # Copyright (c) 2011-2012 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Module that handles the processing of patches to the source tree.""" |
| |
| import constants |
| import logging |
| import os |
| import random |
| import re |
| |
| from chromite.lib import cros_build_lib |
| |
| |
| class PatchException(Exception): |
| """Base exception class all patch exception derive from.""" |
| |
| # Unless instances override it, default all exceptions to ToT. |
| inflight = False |
| |
| def __init__(self, patch, message=None): |
| Exception.__init__(self) |
| self.patch = patch |
| self.message = message |
| self.args = (patch,) |
| if message is not None: |
| self.args += (message,) |
| |
| def __str__(self): |
| return "Change %s failed: %s" % (self.patch, self.message) |
| |
| |
| class ApplyPatchException(PatchException): |
| """Exception thrown if we fail to apply a patch.""" |
| |
| def __init__(self, patch, inflight=False): |
| PatchException.__init__(self, patch) |
| self.inflight = inflight |
| self.args += (inflight,) |
| |
| def __str__(self): |
| return 'Change %s no longer cleanly applies against %s.' % ( |
| self.patch, 'current patch series' if self.inflight else 'ToT') |
| |
| |
| class DependencyError(PatchException): |
| |
| """Exception thrown when a change cannot be applied due to a failure in a |
| dependency.""" |
| |
| def __init__(self, patch, error): |
| """ |
| Args: |
| patch: The GitRepoPatch instance that this exception concerns. |
| error: A PatchException object that can be stringified to describe |
| the error. |
| """ |
| PatchException.__init__(self, patch) |
| self.inflight = error.inflight |
| self.error = error |
| self.args += (error,) |
| |
| def __str__(self): |
| return "Patch %s depends on %s which has an error: %s" % ( |
| self.patch, self.error.patch.id, self.error) |
| |
| |
| class BrokenCQDepends(PatchException): |
| """Raised if a patch has a CQ-DEPEND line that is ill formated.""" |
| |
| def __init__(self, patch, text): |
| PatchException.__init__(self, patch) |
| self.text = text |
| self.args += (text,) |
| |
| def __str__(self): |
| return "Change %s has a malformed CQ-DEPEND target: %s" % ( |
| self.patch, self.text) |
| |
| |
| class BrokenChangeID(PatchException): |
| """Raised if a patch has an invalid or missing Change-ID.""" |
| |
| def __init__(self, patch, message): |
| PatchException.__init__(self, patch) |
| self.message = message |
| self.args += (message,) |
| |
| def __str__(self): |
| return "Change %s has a broken ChangeId: %s" % (self.patch, self.message) |
| |
| |
| def MakeChangeId(unusable=False): |
| """Create a random Change-Id. |
| |
| Args: |
| unusable: If set to True, return a Change-Id like string that gerrit |
| will explicitly fail on. This is primarily used for internal ids, |
| as a fallback when a Change-Id could not be parsed. |
| """ |
| s = "%x" % (random.randint(0, 2**160),) |
| s = s.rjust(40, '0') |
| if unusable: |
| return 'Fake-ID %s' % s |
| return 'I%s' % s |
| |
| |
| def FormatChangeId(text): |
| """Format a Change-ID into a standardized form. Use this anywhere |
| we're accepting user input of Change-IDs.""" |
| if not text: |
| raise ValueError("FormatChangeId invoked w/ an empty value: %r" % (text,)) |
| elif not text[0] in 'iI': |
| raise ValueError("FormatChangeId invoked w/ a malformed Change-Id: %r" % |
| (text,)) |
| return 'I%s' % text[1:].lower() |
| |
| |
| class GitRepoPatch(object): |
| """Representing a patch from a branch of a local or remote git repository.""" |
| |
| # Note the selective case insensitivity; gerrit allows only this. |
| _VALID_CHANGE_ID_RE = re.compile(r'^I[0-9a-fA-F]{40}$') |
| _GIT_CHANGE_ID_RE = re.compile(r'^Change-Id:[\t ]*(\w+)\s*$', |
| re.I|re.MULTILINE) |
| _PALADIN_DEPENDENCY_RE = re.compile(r'^CQ-DEPEND=(.*)$', re.MULTILINE) |
| _PALADIN_BUG_RE = re.compile(r'(\w+)') |
| |
| def __init__(self, project_url, project, ref, tracking_branch, sha1=None, |
| change_id=None): |
| """Initialization of abstract Patch class. |
| |
| Args: |
| project_url: The url of the git repo (can be local or remote) to pull the |
| patch from. |
| project: The name of the project that the patch applies to. |
| ref: The refspec to pull from the git repo. |
| tracking_branch: The remote branch of the project the patch applies to. |
| sha1: The sha1 of the commit, if known. This *must* be accurate. Can |
| be None if not yet known- in which case Fetch will update it. |
| change_id: The Change-Id of the commit, if known. This *must* be |
| accurate. Can be None if not yet known- in which case Fetch will |
| parse it. |
| """ |
| self._commit_message = None |
| self.project_url = project_url |
| self.project = project |
| self.ref = ref |
| self.tracking_branch = os.path.basename(tracking_branch) |
| self.sha1 = sha1 |
| # TODO(ferringb): remove this attribute. |
| # apply_error_message is currently used by ValidationPool as a way to |
| # track what changes have failed. Patch objects shouldn't use this |
| # attribute, instead leaving it purely for validation_pool and friends |
| # to mutate. |
| self.apply_error_message = None |
| # change_id must always be a valid Change-Id (local or gerrit), or None. |
| # id is an internal value- if change-id exists, we use that. If not, |
| # we make up a fake change-id to keep internal apis happy/simple. |
| self.change_id = self.id = change_id |
| self._is_fetched = set() |
| self._projectdir_cache = {} |
| |
| def ProjectDir(self, checkout_root): |
| """Returns the local directory where this patch will be applied.""" |
| checkout_root = os.path.normpath(checkout_root) |
| val = self._projectdir_cache.get(checkout_root) |
| if val is None: |
| val = cros_build_lib.GetProjectDir(checkout_root, self.project) |
| self._projectdir_cache[checkout_root] = val |
| return val |
| |
| def Fetch(self, target_repo): |
| """Fetch this patch into the target repository. |
| |
| FETCH_HEAD is implicitly reset by this operation. Additionally, |
| if the sha1 of the patch was not yet known, it is pulled and stored |
| on this object and the target_repo is updated w/ the requested git |
| object. |
| |
| While doing so, we'll load the commit message and Change-Id if not |
| already known. |
| |
| Finally, if the sha1 is known and it's already available in the target |
| repository, this will skip the actual fetch operation (it's unneeded). |
| """ |
| |
| target_repo = os.path.normpath(target_repo) |
| if target_repo in self._is_fetched: |
| return self.sha1 |
| |
| def _PullData(rev): |
| ret = cros_build_lib.RunCommandCaptureOutput( |
| ['git', 'log', '--format=%H%x00%B', '-n1', rev], print_cmd=False, |
| error_code_ok=True, cwd=target_repo) |
| if ret.returncode != 0: |
| return None, None |
| output = ret.output.split('\0') |
| if len(output) != 2: |
| return None, None |
| return [x.strip() for x in output] |
| |
| if self.sha1 is not None: |
| # See if we've already got the object |
| sha1, msg = _PullData(self.sha1) |
| if sha1 is not None: |
| assert sha1 == self.sha1 |
| self._commit_message = msg |
| self._EnsureId(msg) |
| return self.sha1 |
| |
| cros_build_lib.RunCommand(['git', 'fetch', self.project_url, self.ref], |
| cwd=target_repo, print_cmd=False) |
| |
| sha1, msg = _PullData('FETCH_HEAD') |
| |
| # Even if we know the sha1, still do a sanity check to ensure we |
| # actually just fetched it. |
| if self.sha1 is not None: |
| if sha1 != self.sha1: |
| raise PatchException('Patch %s specifies sha1 %s, yet in fetching from ' |
| '%s we could not find that sha1. Internal error ' |
| 'most likely.' % (self, self.sha1, self.ref)) |
| else: |
| self.sha1 = sha1 |
| self._commit_message = msg |
| self._EnsureId(msg) |
| self._is_fetched.add(target_repo) |
| return self.sha1 |
| |
| def _RebaseOnto(self, branch, upstream, project_dir, rev, trivial): |
| """Attempts to rebase the given rev into branch. |
| |
| Raises: |
| cros_build_lib.RunCommandError: If the rebase operation returns an error code. |
| In this case, we still rebase --abort (or equivalent) before |
| returning. |
| """ |
| try: |
| cmd = ['git', 'rebase'] |
| if trivial: |
| cmd.extend(['--strategy', 'resolve', '-X', 'trivial']) |
| cmd.extend(['--onto', branch, upstream, rev]) |
| |
| # Run the rebase command. |
| cros_build_lib.RunCommand(cmd, cwd=project_dir, print_cmd=False) |
| |
| except cros_build_lib.RunCommandError: |
| cros_build_lib.RunCommand(['git', 'rebase', '--abort'], |
| cwd=project_dir, print_cmd=False, |
| error_code_ok=True) |
| raise |
| |
| def _RebasePatch(self, upstream, project_dir, rev, trivial): |
| """Rebase patch fetched from gerrit onto constants.PATCH_BRANCH. |
| |
| When the function completes, the constants.PATCH_BRANCH branch will be |
| pointing to the rebased change. |
| |
| Arguments: |
| upstream: The upstream branch to base patch on. |
| project_dir: Directory of the project that is being patched. |
| rev: The rev we're rebasing into the tree. |
| trivial: Use trivial logic that only allows trivial merges. Note: |
| Requires Git >= 1.7.6 -- bug <. Bots have 1.7.6 installed. |
| |
| Raises: |
| ApplyPatchException: If the patch failed to apply. |
| """ |
| try: |
| self._RebaseOnto(constants.PATCH_BRANCH, upstream, project_dir, rev, |
| trivial) |
| except cros_build_lib.RunCommandError: |
| # Ignore this error; next we fiddle with the patch a bit to |
| # discern what exception to throw. |
| pass |
| else: |
| cros_build_lib.RunCommand( |
| ['git', 'checkout', '-B', constants.PATCH_BRANCH, 'HEAD'], |
| cwd=project_dir, print_cmd=False) |
| return |
| |
| try: |
| self._RebaseOnto(upstream, upstream, project_dir, rev, trivial) |
| raise ApplyPatchException(self, inflight=True) |
| except cros_build_lib.RunCommandError: |
| # Cleanup the rebase attempt. |
| cros_build_lib.RunCommandCaptureOutput( |
| ['git', 'rebase', '--abort'], cwd=project_dir, print_cmd=False, |
| error_code_ok=True) |
| raise ApplyPatchException(self, inflight=False) |
| |
| finally: |
| # Ensure we're on the correct branch on the way out. |
| cros_build_lib.RunCommand(['git', 'checkout', constants.PATCH_BRANCH], |
| cwd=project_dir, print_cmd=False) |
| |
| def _GetUpstreamBranch(self, buildroot, force_default=False): |
| """Get the branch specified in the manifest for this patch.""" |
| # TODO(ferringb): remove this via cherry-picking; it's broken |
| # now since it assumes the tracking_branch (which is local |
| # to the originating repo) is what should be used for rebasing |
| # this patch into the current tree). |
| manifest = cros_build_lib.ManifestCheckout.Cached(buildroot) |
| if force_default: |
| return manifest.default_branch |
| return manifest.GetProjectsLocalRevision(self.project) |
| |
| def ApplyIntoGitRepo(self, project_dir, upstream, trivial=False, |
| do_check=True): |
| """Apply patch into a standalone git repo. |
| |
| The git repo does not need to be part of a repo checkout. |
| |
| Arguments: |
| project_dir: The directory of the project. |
| upstream: The branch to base the patch on. |
| trivial: Only allow trivial merges when applying change. |
| do_check: Check if tracking is the same as the given upstream. |
| """ |
| # Check that the patch is based on the same branch as project we are |
| # patching into. |
| # TODO(ferringb): remove this when cherry-pick lands; has questionable |
| # value now, has no relevance/value once cherry-picking is in. |
| branch_base = os.path.basename(upstream) |
| if self.tracking_branch != branch_base and do_check: |
| raise PatchException('branch %s for project %s is not tracking %s' |
| % (self.ref, self.project, branch_base)) |
| |
| rev = self.Fetch(project_dir) |
| |
| if not cros_build_lib.DoesLocalBranchExist(project_dir, |
| constants.PATCH_BRANCH): |
| cmd = ['checkout', '-b', constants.PATCH_BRANCH, '-t', upstream] |
| cros_build_lib.RunGitCommand(project_dir, cmd) |
| |
| self._RebasePatch(upstream, project_dir, rev, trivial) |
| |
| def Apply(self, buildroot, trivial=False): |
| """Applies the patch to specified buildroot. |
| |
| buildroot: The buildroot. |
| trivial: Only allow trivial merges when applying change. |
| |
| Raises: |
| ApplyPatchException: If the patch failed to apply. |
| """ |
| logging.info('Attempting to apply change %s', self) |
| manifest_branch = self._GetUpstreamBranch(buildroot) |
| do_check = manifest_branch.startswith('refs/') |
| if not do_check: |
| # Revision locked. Use the manifest default branch which |
| # is set to the manifest locked revision, and |
| # suppress the tracking/upstream check. |
| manifest_branch = self._GetUpstreamBranch(buildroot, True) |
| project_dir = self.ProjectDir(buildroot) |
| self.ApplyIntoGitRepo(project_dir, manifest_branch, trivial, |
| do_check=do_check) |
| |
| def GerritDependencies(self, buildroot): |
| """Returns an ordered list of dependencies from Gerrit. |
| |
| The list of changes are in order from FETCH_HEAD back to m/master. |
| |
| Arguments: |
| buildroot: The buildroot. |
| Returns: |
| An ordered list of Gerrit revisions that this patch depends on. |
| Raises: |
| BrokenChangeID: If a dependent change is missing its ChangeID. |
| """ |
| dependencies = [] |
| logging.info('Checking for Gerrit dependencies for change %s', self) |
| project_dir = self.ProjectDir(buildroot) |
| |
| rev = self.Fetch(project_dir) |
| |
| tracking_branch = self._GetUpstreamBranch(buildroot) |
| try: |
| return_obj = cros_build_lib.RunGitCommand( |
| project_dir, |
| ['log', '--format=%B%x00', '%s..%s^' % (tracking_branch, rev)]) |
| except cros_build_lib.RunCommandError, e: |
| if e.result.returncode != 128: |
| raise |
| # Errorcode 128 means "object not found"; either we've got an |
| # internal bug (tracking_branch was wrong, fetch somehow didn't get |
| # that actual rev, etc), or... this is the first commit in a repository. |
| # The following code checks for that, raising the original |
| # exception if not. |
| result = cros_build_lib.RunGitCommand(project_dir, |
| ['rev-list', '-n2', rev]) |
| if len(result.output.split()) != 1: |
| raise |
| # First commit of a repository; obviously, it has no dependencies. |
| return [] |
| |
| patches = [] |
| if return_obj.output: |
| # Only do this if we have output; else it leads |
| # to an invalid [''] result which we can't identify |
| # as differing from actual output for a single patch that |
| # lacks a commit message. |
| # Because the explicit null addition, strip off the last record. |
| patches = return_obj.output.split('\0')[:-1] |
| |
| for patch_output in patches: |
| change_id = self._ParseChangeId(patch_output) |
| dependencies.append(change_id) |
| |
| if dependencies: |
| logging.info('Found %s Gerrit dependencies for change %s', dependencies, |
| self) |
| |
| return dependencies |
| |
| def _EnsureId(self, commit_message): |
| """Ensure we have a usable Change-Id. This will parse the Change-Id out |
| of the given commit message- if it cannot find one, it logs a warning |
| and creates a fake ID. |
| |
| By it's nature, that fake ID is useless- it's created to simplify API |
| usage for patch consumers. |
| |
| If CQ were to see and try operating on one of these, it would fail for |
| example.""" |
| if self.id is not None: |
| return self.id |
| try: |
| self.change_id = self.id = self._ParseChangeId(commit_message) |
| except BrokenChangeID: |
| logging.warning( |
| 'Change %s, sha1 %s lacks a change-id in its commit ' |
| 'message. CQ-DEPEND against this rev will not work, nor ' |
| 'will any gerrit querying. Please add the appropriate ' |
| 'Change-Id into the commit message to resolve this.', |
| self, self.sha1) |
| |
| # We still need an internal id to address it via- thus we |
| # make a fake one to keep our caches/resolvers happy, while |
| # leaving the authoritive .change_id set to None. |
| self.id = MakeChangeId(unusable=True) |
| return self.id |
| |
| def _ParseChangeId(self, data): |
| """Parse a Change-Id out of a block of text.""" |
| # Grab just the last pararaph. |
| git_metadata = re.split('\n{2,}', data.rstrip())[-1] |
| change_id_match = self._GIT_CHANGE_ID_RE.findall(git_metadata) |
| if not change_id_match: |
| raise BrokenChangeID(self, 'Missing Change-Id in %s' % (data,)) |
| |
| # Now, validate it. This has no real effect on actual gerrit patches, |
| # but for local patches the validation is useful for general sanity |
| # enforcement. |
| change_id_match = change_id_match[-1] |
| if not self._VALID_CHANGE_ID_RE.match(change_id_match): |
| raise BrokenChangeID(self, change_id_match) |
| |
| # Force a standard for the formatting; I must be caps, force the rest |
| # of the hex to lower case. |
| return FormatChangeId(change_id_match) |
| |
| def PaladinDependencies(self, buildroot): |
| """Returns an ordered list of dependencies based on the Commit Message. |
| |
| Parses the Commit message for this change looking for lines that follow |
| the format: |
| |
| CQ-DEPEND:change_num+ e.g. |
| |
| A commit which depends on a couple others. |
| |
| BUG=blah |
| TEST=blah |
| CQ-DEPEND=10001,10002 |
| """ |
| dependencies = [] |
| logging.info('Checking for CQ-DEPEND dependencies for change %s', self) |
| self.Fetch(self.ProjectDir(buildroot)) |
| matches = self._PALADIN_DEPENDENCY_RE.findall(self._commit_message) |
| for match in matches: |
| chunks = ' '.join(match.split(',')) |
| chunks = chunks.split() |
| for chunk in chunks: |
| if not chunk.isdigit(): |
| if not self._VALID_CHANGE_ID_RE.match(chunk): |
| raise BrokenCQDepends(self, chunk) |
| chunk = FormatChangeId(chunk) |
| if chunk not in dependencies: |
| dependencies.append(chunk) |
| |
| if dependencies: |
| logging.info('Found %s Paladin dependencies for change %s', dependencies, |
| self) |
| return dependencies |
| |
| def __str__(self): |
| """Returns custom string to identify this patch.""" |
| s = '%s:%s' % (self.project, self.ref) |
| if self.sha1 is not None: |
| s = '%s:%s' % (s, self.sha1[:8]) |
| return s |
| |
| |
| class LocalPatch(GitRepoPatch): |
| """Represents patch coming from an on-disk git repo.""" |
| |
| def __init__(self, project_url, project, ref, tracking_branch, sha1): |
| GitRepoPatch.__init__(self, project_url, project, ref, tracking_branch, |
| sha1=sha1) |
| |
| def Sha1Hash(self): |
| """Get the Sha1 of the branch.""" |
| return self.sha1 |
| |
| def _GetCarbonCopy(self): |
| """Returns a copy of this commit object, with a different sha1. |
| |
| This is used to work around a Gerrit bug, where a commit object cannot be |
| uploaded for review if an existing branch (in refs/tryjobs/*) points to |
| that same sha1. So instead we create a copy of the commit object and upload |
| that to refs/tryjobs/*. |
| |
| Returns: |
| The sha1 of the new commit object. |
| """ |
| hash_fields = [('tree_hash', '%T'), ('parent_hash', '%P')] |
| transfer_fields = [('GIT_AUTHOR_NAME', '%an'), |
| ('GIT_AUTHOR_EMAIL', '%ae'), |
| ('GIT_AUTHOR_DATE', '%ad'), |
| ('GIT_COMMITTER_NAME', '%cn'), |
| ('GIT_COMMITTER_EMAIL', '%ce'), |
| ('GIT_COMMITER_DATE', '%ct')] |
| fields = hash_fields + transfer_fields |
| |
| format_string = '%n'.join([code for _, code in fields] + ['%B']) |
| result = cros_build_lib.RunGitCommand( |
| self.project_url, |
| ['log', '--format=%s' % format_string, '-z', '-n1', self.sha1]) |
| lines = result.output.splitlines() |
| field_value = dict(zip([name for name, _ in fields], |
| [line.strip() for line in lines])) |
| commit_body = '\n'.join(lines[len(fields):]) |
| |
| if len(field_value['parent_hash'].split()) != 1: |
| raise PatchException('Branch %s:%s contains merge result %s!' |
| % (self.project, self.ref, self.sha1)) |
| |
| extra_env = dict([(field, field_value[field]) for field, _ in |
| transfer_fields]) |
| |
| # Reset the commit date to a value that can't conflict; if we |
| # leave this to git, it's possible for a fast moving set of commit/uploads |
| # to all occur within the same second (thus the same commit date), |
| # resulting in the same sha1. |
| extra_env['GIT_COMMITTER_DATE'] = str( |
| int(extra_env["GIT_COMMITER_DATE"]) - 1) |
| |
| result = cros_build_lib.RunGitCommand( |
| self.project_url, |
| ['commit-tree', field_value['tree_hash'], '-p', |
| field_value['parent_hash']], |
| extra_env=extra_env, input=commit_body) |
| |
| new_sha1 = result.output.strip() |
| if new_sha1 == self.sha1: |
| raise PatchException( |
| 'Internal error! Carbon copy of %s is the same as original!' |
| % self.sha1) |
| |
| return new_sha1 |
| |
| def Upload(self, push_url, remote_ref, dryrun=False): |
| """Upload the patch to a remote git branch. |
| |
| Arguments: |
| push_url: Which url to push to. |
| remote_ref: The ref on the remote host to push to. |
| dryrun: Do the git push with --dry-run |
| """ |
| carbon_copy = self._GetCarbonCopy() |
| cmd = ['push', push_url, '%s:%s' % (carbon_copy, remote_ref)] |
| if dryrun: |
| cmd.append('--dry-run') |
| |
| cros_build_lib.RunGitCommand(self.project_url, cmd) |
| |
| |
| class UploadedLocalPatch(GitRepoPatch): |
| """Represents an uploaded local patch passed in using --remote-patch.""" |
| def __init__(self, project_url, project, ref, tracking_branch, |
| original_branch, original_sha1, carbon_copy_sha1=None): |
| GitRepoPatch.__init__(self, project_url, project, ref, tracking_branch, |
| sha1=carbon_copy_sha1) |
| self.original_branch = original_branch |
| self.original_sha1 = original_sha1 |
| |
| def __str__(self): |
| """Returns custom string to identify this patch.""" |
| # TODO(ferringb): fold subject line in here. |
| s = '%s:%s:%s' % (self.project, self.original_branch, |
| self.original_sha1[:8]) |
| return s |
| |
| |
| class GerritPatch(GitRepoPatch): |
| """Object that represents a Gerrit CL.""" |
| _PUBLIC_URL = os.path.join(constants.GERRIT_HTTP_URL, 'gerrit/p') |
| |
| def __init__(self, patch_dict, internal): |
| """Construct a GerritPatch object from Gerrit query results. |
| |
| Gerrit query JSON fields are documented at: |
| http://gerrit-documentation.googlecode.com/svn/Documentation/2.2.1/json.html |
| |
| Args: |
| patch_dict: A dictionary containing the parsed JSON gerrit query results. |
| internal: Whether the CL is an internal CL. |
| """ |
| self.patch_dict = patch_dict |
| super(GerritPatch, self).__init__( |
| self._GetProjectUrl(patch_dict['project'], internal), |
| patch_dict['project'], |
| patch_dict['currentPatchSet']['ref'], |
| patch_dict['branch'], |
| sha1=patch_dict['currentPatchSet']['revision'], |
| change_id=FormatChangeId(patch_dict['id'])) |
| |
| self.internal = internal |
| # id - The CL's ChangeId |
| # revision - The CL's SHA1 hash. |
| self.revision = patch_dict['currentPatchSet']['revision'] |
| self.patch_number = patch_dict['currentPatchSet']['number'] |
| self.commit = patch_dict['currentPatchSet']['revision'] |
| self.owner, _, _ = patch_dict['owner']['email'].partition('@') |
| self.gerrit_number = patch_dict['number'] |
| self.url = patch_dict['url'] |
| # status - Current state of this change. Can be one of |
| # ['NEW', 'SUBMITTED', 'MERGED', 'ABANDONED']. |
| self.status = patch_dict['status'] |
| |
| def __reduce__(self): |
| """Used for pickling to re-create patch object.""" |
| return self.__class__, (self.patch_dict.copy(), self.internal) |
| |
| def IsAlreadyMerged(self): |
| """Returns whether the patch has already been merged in Gerrit.""" |
| return self.status == 'MERGED' |
| |
| @classmethod |
| def _GetProjectUrl(cls, project, internal): |
| """Returns the url to the gerrit project.""" |
| if internal: |
| url_prefix = constants.GERRIT_INT_SSH_URL |
| else: |
| url_prefix = cls._PUBLIC_URL |
| |
| return os.path.join(url_prefix, project) |
| |
| def _EnsureId(self, commit_message): |
| """Ensure we have a usable Change-Id, validating what we received |
| from gerrit against what the commit message states.""" |
| # GerritPatch instances get their Change-Id from gerrit |
| # directly; for this to fail, there is an internal bug. |
| assert self.id is not None |
| |
| # For GerritPatches, we still parse the ID- this is |
| # primarily so we can throw an appropriate warning, |
| # and also validate our parsing against gerrit's in |
| # the process. |
| try: |
| parsed_id = self._ParseChangeId(commit_message) |
| if parsed_id != self.change_id: |
| raise AssertionError( |
| 'For Change-Id %s, sha %s, our parsing of the Change-Id did not ' |
| 'match what gerrit told us. This is an internal bug: either our ' |
| "parsing no longer matches gerrit's, or somehow this instance's " |
| 'stored change_id was invalidly modified. Our parsing of the ' |
| 'Change-Id yielded: %s' |
| % (self.change_id, self.sha1, parsed_id)) |
| |
| except BrokenChangeID: |
| logging.warning( |
| 'Change %s, Change-Id %s, sha1 %s lacks a change-id in its commit ' |
| 'message. This breaks the ability for any dependencies ' |
| 'to be committed as a batch (instead having to be committed one ' |
| 'by one through CQ). Please add the appropriate ' |
| 'Change-Id into the commit message to resolve this.', |
| self, self.change_id, self.sha1) |
| |
| return self.id |
| |
| def __str__(self): |
| """Returns custom string to identify this patch.""" |
| s = '%s:%s' % (self.owner, self.gerrit_number) |
| if self.sha1 is not None: |
| s = '%s:%s' % (s, self.sha1[:8]) |
| return s |
| |
| # Define methods to use patches in sets. We uniquely identify patches |
| # by Gerrit change numbers. |
| def __hash__(self): |
| return hash(self.id) |
| |
| def __eq__(self, other): |
| return self.id == other.id |
| |
| |
| |
| def PrepareLocalPatches(manifest, patches): |
| """Finish validation of parameters, and save patches to a temp folder. |
| |
| Args: |
| manifest: The manifest object for the checkout in question. |
| patches: A list of user-specified patches, in project[:branch] form. |
| """ |
| patch_info = [] |
| for patch in patches: |
| project, branch = patch.split(':') |
| project_dir = manifest.GetProjectPath(project, True) |
| tracking_branch = manifest.GetProjectsLocalRevision(project) |
| |
| cmd = ['git', 'rev-list', '-n1', '%s..%s' % (tracking_branch, branch)] |
| result = cros_build_lib.RunCommand(cmd, redirect_stdout=True, |
| cwd=project_dir) |
| sha1 = result.output.strip() |
| |
| if not sha1: |
| cros_build_lib.Die('No changes found in %s:%s' % (project, branch)) |
| |
| patch_info.append(LocalPatch(os.path.join(project_dir, '.git'), |
| project, branch, tracking_branch, |
| sha1)) |
| |
| return patch_info |
| |
| |
| def PrepareRemotePatches(patches): |
| """Generate patch objects from list of --remote-patch parameters. |
| |
| Args: |
| patches: A list of --remote-patches strings that the user specified on |
| the commandline. Patch strings are colon-delimited. Patches come |
| in the format |
| <project>:<original_branch>:<ref>:<tracking_branch>:<tag>. |
| A description of each element: |
| project: The manifest project name that the patch is for. |
| original_branch: The name of the development branch that the local |
| patch came from. |
| ref: The remote ref that points to the patch. |
| tracking_branch: The upstream branch that the original_branch was |
| tracking. Should be a manifest branch. |
| tag: Denotes whether the project is an internal or external |
| project. |
| """ |
| patch_info = [] |
| for patch in patches: |
| try: |
| project, original_branch, ref, tracking_branch, tag = patch.split(':') |
| except ValueError: |
| cros_build_lib.Die( |
| "Unexpected tryjob format. You may be running an " |
| "older version of chromite. Run 'repo sync " |
| "chromiumos/chromite'.") |
| |
| if tag == constants.EXTERNAL_PATCH_TAG: |
| push_url = constants.GERRIT_SSH_URL |
| elif tag == constants.INTERNAL_PATCH_TAG: |
| push_url = constants.GERRIT_INT_SSH_URL |
| else: |
| raise ValueError('Bad remote patch format. Unknown tag %s' % tag) |
| |
| patch_info.append(UploadedLocalPatch(os.path.join(push_url, project), |
| project, ref, tracking_branch, |
| original_branch, |
| os.path.basename(ref))) |
| |
| return patch_info |
