From 121dbe56ddaba18ec5b15758ed669afd2e9acfd9 Mon Sep 17 00:00:00 2001 From: Jian Cai Date: Wed, 20 Nov 2019 15:32:56 -0800 Subject: toolchain-utils: use LLVM git hashes to track version numbers. LLVM has stopped issuing SVN version numbers in its commits. This patch adds a way to track SVN-style version number based on a LLVM git hash. BUG=Chromium:1027950 TEST=local tests. Change-Id: Idd8055ea7deb3bcd17c18ab5b642ce8b389e446a Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/third_party/toolchain-utils/+/1915373 Tested-by: Jian Cai Reviewed-by: Manoj Gupta --- llvm_tools/README.md | 8 -- llvm_tools/get_llvm_hash.py | 196 ++++++++------------------- llvm_tools/get_llvm_hash_unittest.py | 76 ++--------- llvm_tools/git_llvm_rev.py | 8 +- llvm_tools/llvm_bisection.py | 9 +- llvm_tools/llvm_bisection_unittest.py | 26 ++-- llvm_tools/llvm_patch_management.py | 16 +-- llvm_tools/llvm_patch_management_unittest.py | 19 +-- llvm_tools/patch_manager.py | 38 +++--- 9 files changed, 126 insertions(+), 270 deletions(-) (limited to 'llvm_tools') diff --git a/llvm_tools/README.md b/llvm_tools/README.md index abf7a6f9..52bc263f 100644 --- a/llvm_tools/README.md +++ b/llvm_tools/README.md @@ -463,14 +463,6 @@ from get_llvm_hash import LLVMHash LLVMHash().GetLLVMHash() ``` -For example, to retrieve the commit message of a git hash of LLVM: - -``` -from get_llvm_hash import LLVMHash - -LLVMHash.GetCommitMessageForHash() -``` - For example, to retrieve the latest google3 LLVM version: ``` diff --git a/llvm_tools/get_llvm_hash.py b/llvm_tools/get_llvm_hash.py index 914bbfbf..01acbfaf 100755 --- a/llvm_tools/get_llvm_hash.py +++ b/llvm_tools/get_llvm_hash.py @@ -15,6 +15,7 @@ import shutil import subprocess import sys import tempfile +import git_llvm_rev from contextlib import contextmanager from subprocess_helpers import CheckCommand @@ -28,6 +29,44 @@ _LLVM_GIT_URL = ('https://chromium.googlesource.com/external/github.com/llvm' KNOWN_HASH_SOURCES = {'google3', 'google3-unstable', 'tot'} +def GetVersionFrom(src_dir, git_hash): + """Obtain an SVN-style version number based on the LLVM git hash passed in. + + Args: + git_hash: The git hash. + + Returns: + An SVN-style version number associated with the git hash. + """ + + args = ['--llvm_dir', src_dir, '--sha', git_hash] + version = git_llvm_rev.main(args).strip() + assert version.startswith('r') + return int(version[1:]) + + +def GetGitHashFrom(src_dir, version): + """Finds the commit hash(es) of the LLVM version in the git log history. + + Args: + src_dir: The LLVM source tree. + version: The version number. + + Returns: + A git hash string corresponding to the version number. + + Raises: + subprocess.CalledProcessError: Failed to find a git hash. + """ + + assert isinstance(version, int) + args = ['--llvm_dir', src_dir, '--rev', 'r' + str(version)] + + git_hash = git_llvm_rev.main(args).rstrip() + + return git_hash + + @contextmanager def CreateTempLLVMRepo(temp_dir): """Adds a LLVM worktree to 'temp_dir'. @@ -134,18 +173,19 @@ def GetGoogle3LLVMVersion(stable): """ subdir = 'stable' if stable else 'llvm_unstable' - path_to_google3_llvm_version = os.path.join( - '/google/src/head/depot/google3/third_party/crosstool/v18', subdir, - 'installs/llvm/revision') # Cmd to get latest google3 LLVM version. - cat_cmd = ['cat', path_to_google3_llvm_version] + cmd = [ + 'cat', + os.path.join('/google/src/head/depot/google3/third_party/crosstool/v18', + subdir, 'installs/llvm/git_origin_rev_id') + ] # Get latest version. - g3_version = check_output(cat_cmd) + git_hash = check_output(cmd) # Change type to an integer - return int(g3_version.rstrip()) + return GetVersionFrom(GetAndUpdateLLVMProjectInLLVMTools(), git_hash.strip()) def is_svn_option(svn_option): @@ -192,24 +232,18 @@ def GetLLVMHashAndVersionFromSVNOption(svn_option): # Determine which LLVM git hash to retrieve. if svn_option == 'tot': - llvm_hash = new_llvm_hash.GetTopOfTrunkGitHash() - - tot_commit_message = new_llvm_hash.GetCommitMessageForHash(llvm_hash) - - llvm_version = new_llvm_hash.GetSVNVersionFromCommitMessage( - tot_commit_message) + git_hash = new_llvm_hash.GetTopOfTrunkGitHash() + version = GetVersionFrom(GetAndUpdateLLVMProjectInLLVMTools(), git_hash) elif isinstance(svn_option, int): - llvm_version = svn_option - llvm_hash = new_llvm_hash.GetGitHashForVersion( - GetAndUpdateLLVMProjectInLLVMTools(), llvm_version) + version = svn_option + git_hash = GetGitHashFrom(GetAndUpdateLLVMProjectInLLVMTools(), version) else: assert svn_option in ('google3', 'google3-unstable') - llvm_version = GetGoogle3LLVMVersion(stable=svn_option == 'google3') + version = GetGoogle3LLVMVersion(stable=svn_option == 'google3') - llvm_hash = new_llvm_hash.GetGitHashForVersion( - GetAndUpdateLLVMProjectInLLVMTools(), llvm_version) + git_hash = GetGitHashFrom(GetAndUpdateLLVMProjectInLLVMTools(), version) - return llvm_hash, llvm_version + return git_hash, version class LLVMHash(object): @@ -244,135 +278,17 @@ class LLVMHash(object): if clone_cmd_obj.returncode: raise ValueError('Failed to clone the LLVM repo: %s' % stderr) - def GetCommitMessageForHash(self, git_hash): - """Gets the commit message from the git hash. - - Args: - git_hash: A git hash of LLVM. - - Returns: - The commit message of the git hash. - - Raises: - ValueError: Unable to retrieve json contents from the LLVM commit URL. - """ - - llvm_commit_url = ('https://api.github.com/repos/llvm/llvm-project/git/' - 'commits/') - - commit_url = os.path.join(llvm_commit_url, git_hash) - - url_response = requests.get(commit_url) - - if not url_response: - raise ValueError('Failed to get response from url %s: Status Code %d' % - (commit_url, url_response.status_code)) - - unicode_json_contents = url_response.json() - - return str(unicode_json_contents['message']) - - def GetSVNVersionFromCommitMessage(self, commit_message): - """Gets the 'llvm-svn' from the commit message. - - A commit message may contain multiple 'llvm-svn' (reverting commits), so - the last 'llvm-svn' is the real 'llvm-svn' for that commit message. - - Args: - commit_message: A commit message that contains a 'llvm-svn:'. - - Returns: - The last LLVM version as an integer or 'None' if there is no 'llvm-svn'. - """ - - # Find all "llvm-svn:" instances. - llvm_versions = re.findall(r'llvm-svn: ([0-9]+)', commit_message) - - if llvm_versions: - return int(llvm_versions[-1]) - - return None - - def _ParseCommitMessages(self, subdir, hash_vals, llvm_version): - """Parses the hashes that match the LLVM version. - - Args: - subdir: The directory where the git history resides. - hash_vals: All the hashes that match the LLVM version. - llvm_version: The version to compare to in the commit message. - - Returns: - The hash that matches the LLVM version. - - Raises: - subprocess.CalledProcessError: Failed to retrieve the commit message body. - ValueError: Failed to parse a commit message or did not find a commit - hash. - """ - - # For each hash, grab the last "llvm-svn:" line - # and compare the llvm version of that line against - # the llvm version we are looking for and return - # that hash only if they match. - for cur_commit in hash_vals.splitlines(): - cur_hash = cur_commit.split()[0] # Get hash. - - # Cmd to output the commit body. - find_llvm_cmd = [ - 'git', '-C', subdir, 'log', '--format=%B', '-n', '1', cur_hash - ] - - out = check_output(find_llvm_cmd) - - commit_svn_version = self.GetSVNVersionFromCommitMessage(out.rstrip()) - - # Check the svn version from the commit message against the llvm version - # we are looking for. - if commit_svn_version and commit_svn_version == llvm_version: - return cur_hash - - # Failed to find the commit hash. - raise ValueError('Could not find commit hash.') - - def GetGitHashForVersion(self, llvm_git_dir, llvm_version): - """Finds the commit hash(es) of the LLVM version in the git log history. - - Args: - llvm_git_dir: The LLVM git directory. - llvm_version: The version to search for in the git log history. - - Returns: - A string of the hash corresponding to the LLVM version. - - Raises: - subprocess.CalledProcessError: Failed to retrieve git hashes that match - 'llvm_version'. - """ - - # Get all the git hashes that match 'llvm_version'. - hash_cmd = [ - 'git', '-C', llvm_git_dir, 'log', '--oneline', '--no-abbrev', '--grep', - 'llvm-svn: %d' % llvm_version - ] - - hash_vals = check_output(hash_cmd) - - return self._ParseCommitMessages(llvm_git_dir, hash_vals.rstrip(), - llvm_version) - - def GetLLVMHash(self, llvm_version): + def GetLLVMHash(self, version): """Retrieves the LLVM hash corresponding to the LLVM version passed in. Args: - llvm_version: The LLVM version to use as a delimiter. + version: The LLVM version to use as a delimiter. Returns: The hash as a string that corresponds to the LLVM version. """ - hash_value = self.GetGitHashForVersion(GetAndUpdateLLVMProjectInLLVMTools(), - llvm_version) - + hash_value = GetGitHashFrom(GetAndUpdateLLVMProjectInLLVMTools(), version) return hash_value def GetGoogle3LLVMHash(self): diff --git a/llvm_tools/get_llvm_hash_unittest.py b/llvm_tools/get_llvm_hash_unittest.py index 895ee2b6..c828f433 100755 --- a/llvm_tools/get_llvm_hash_unittest.py +++ b/llvm_tools/get_llvm_hash_unittest.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # -*- coding: utf-8 -*- # Copyright 2019 The Chromium OS Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be @@ -8,13 +8,13 @@ from __future__ import print_function +import get_llvm_hash import subprocess import unittest +import unittest.mock as mock +import test_helpers -import get_llvm_hash from get_llvm_hash import LLVMHash -import mock -import test_helpers # We grab protected stuff from get_llvm_hash. That's OK. # pylint: disable=protected-access @@ -55,71 +55,17 @@ class TestGetLLVMHash(unittest.TestCase): with self.assertRaises(ValueError) as err: LLVMHash().CloneLLVMRepo('/tmp/tmp1') - self.assertIn('Failed to clone', err.exception.message) - self.assertIn('some stderr', err.exception.message) - - @mock.patch.object(subprocess, 'check_output') - def testParseCommitMessageWithoutAHashFails(self, check_output_mock): - check_output_mock.return_value = ('[Test] Test sentence.\n\n' - 'A change was made.\n\n' - 'llvm-svn: 1000') - - # Verify the exception is raised when failed to find the commit hash. - with self.assertRaises(ValueError) as err: - LLVMHash()._ParseCommitMessages('/tmp/tmpTest', - 'a13testhash2 This is a test', 100) + self.assertIn('Failed to clone', str(err.exception.args)) + self.assertIn('some stderr', str(err.exception.args)) - self.assertEqual(err.exception.message, 'Could not find commit hash.') - check_output_mock.assert_called_once() - - @mock.patch.object(subprocess, 'check_output') - def testParseCommitMessageIgnoresSVNMarkersInReverts(self, check_output_mock): - output_messages = [ - '[Test] Test sentence.\n\n' - 'A change was made.\n\n' - 'llvm-svn: 1001', - '[Revert] Reverted commit.\n\n' - 'This reverts r1000:\n\n' - ' [Test2] Update.\n\n' - ' This updates stuff.\n\n' - ' llvm-svn: 1000\n\n' - 'llvm-svn: 58', - '[Revert] Reverted commit.\n\n' - 'This reverts r958:\n\n' - ' [Test2] Update.\n\n' - ' This updates stuff.\n\n' - ' llvm-svn: 958\n\n' - 'llvm-svn: 1000', - ] - - @test_helpers.CallCountsToMockFunctions - def MultipleCommitMessages(call_count, *_args, **_kwargs): - return output_messages[call_count] - - check_output_mock.side_effect = MultipleCommitMessages - - hash_vals = ('a13testhash2 [Test] Test sentence.\n' - 'a13testhash3 [Revert] Reverted commit.\n' - 'a13testhash4 [Revert] Reverted commit.') + @mock.patch.object(get_llvm_hash, 'GetGitHashFrom') + def testGetGitHashWorks(self, mock_get_git_hash): + mock_get_git_hash.return_value = 'a13testhash2' self.assertEqual( - LLVMHash()._ParseCommitMessages('/tmp/tmpTest', hash_vals, 1000), - 'a13testhash4') + get_llvm_hash.GetGitHashFrom('/tmp/tmpTest', 100), 'a13testhash2') - self.assertEqual(check_output_mock.call_count, 3) - - @mock.patch.object(subprocess, 'check_output') - @mock.patch.object(LLVMHash, '_ParseCommitMessages') - def testGetGitHashWorks(self, mock_return_hash_val, mock_check_output): - mock_check_output.return_value = 'a13testhash2 [Test] Test sentence.' - mock_return_hash_val.return_value = 'a13testhash2' - - self.assertEqual(LLVMHash().GetGitHashForVersion('/tmp/tmpTest', 100), - 'a13testhash2') - - mock_return_hash_val.assert_called_once_with( - '/tmp/tmpTest', 'a13testhash2 [Test] Test sentence.', 100) - mock_check_output.assert_called_once() + mock_get_git_hash.assert_called_once() @mock.patch.object(LLVMHash, 'GetLLVMHash') @mock.patch.object(get_llvm_hash, 'GetGoogle3LLVMVersion') diff --git a/llvm_tools/git_llvm_rev.py b/llvm_tools/git_llvm_rev.py index 4c9fed12..76a67d65 100755 --- a/llvm_tools/git_llvm_rev.py +++ b/llvm_tools/git_llvm_rev.py @@ -343,9 +343,13 @@ def main(argv: t.List[str]) -> None: ) if opts.sha: - print(translate_sha_to_rev(config, opts.sha)) + rev = str(translate_sha_to_rev(config, opts.sha)) + print(rev) + return rev else: - print(translate_rev_to_sha(config, Rev.parse(opts.rev))) + sha = str(translate_rev_to_sha(config, Rev.parse(opts.rev))) + print(sha) + return sha if __name__ == '__main__': diff --git a/llvm_tools/llvm_bisection.py b/llvm_tools/llvm_bisection.py index b45be0aa..4ff921d2 100755 --- a/llvm_tools/llvm_bisection.py +++ b/llvm_tools/llvm_bisection.py @@ -11,6 +11,7 @@ from __future__ import print_function import argparse import enum import errno +import get_llvm_hash import json import os import sys @@ -268,7 +269,7 @@ def GetRevisionsBetweenBisection(start, end, parallel, src_path, cur_revision not in skip_revisions: # Verify that the current revision exists by finding its corresponding # git hash in the LLVM source tree. - new_llvm.GetGitHashForVersion(src_path, cur_revision) + get_llvm_hash.GetGitHashFrom(src_path, cur_revision) valid_revisions.append(cur_revision) except ValueError: # Could not find the git hash for the current revision. @@ -302,9 +303,7 @@ def GetRevisionsListAndHashList(start, end, parallel, src_path, revisions = GetRevisionsBetweenBisection( start, end, parallel, src_path, pending_revisions, skip_revisions) - git_hashes = [ - new_llvm.GetGitHashForVersion(src_path, rev) for rev in revisions - ] + git_hashes = [get_llvm_hash.GetGitHashFrom(src_path, rev) for rev in revisions] return revisions, git_hashes @@ -363,7 +362,7 @@ def _NoteCompletedBisection(last_tested, src_path, end): print('Finished bisecting for %s' % last_tested) if src_path: - bad_llvm_hash = LLVMHash().GetGitHashForVersion(src_path, end) + bad_llvm_hash = get_llvm_hash.GetGitHashFrom(src_path, end) else: bad_llvm_hash = LLVMHash().GetLLVMHash(end) diff --git a/llvm_tools/llvm_bisection_unittest.py b/llvm_tools/llvm_bisection_unittest.py index 946a56ff..ccef649c 100755 --- a/llvm_tools/llvm_bisection_unittest.py +++ b/llvm_tools/llvm_bisection_unittest.py @@ -8,7 +8,9 @@ from __future__ import print_function +import get_llvm_hash import json +import llvm_bisection import unittest import unittest.mock as mock @@ -17,7 +19,6 @@ from test_helpers import ArgsOutputTest from test_helpers import CallCountsToMockFunctions from test_helpers import CreateTemporaryJsonFile from test_helpers import WritePrettyJsonFile -import llvm_bisection class LLVMBisectionTest(unittest.TestCase): @@ -144,7 +145,7 @@ class LLVMBisectionTest(unittest.TestCase): llvm_bisection.GetStartAndEndRevision(start, end, test_tryjobs), expected_revisions_tuple) - @mock.patch.object(LLVMHash, 'GetGitHashForVersion') + @mock.patch.object(get_llvm_hash, 'GetGitHashFrom') def testNoRevisionsBetweenStartAndEnd(self, mock_get_git_hash): start = 100 end = 110 @@ -152,7 +153,7 @@ class LLVMBisectionTest(unittest.TestCase): test_pending_revisions = {107} test_skip_revisions = {101, 102, 103, 104, 108, 109} - # Simulate behavior of `GetGitHashForVersion()` when the revision does not + # Simulate behavior of `GetGitHashFrom()` when the revision does not # exist in the LLVM source tree. def MockGetGitHashForRevisionRaiseException(src_path, revision): raise ValueError('Revision does not exist') @@ -168,7 +169,8 @@ class LLVMBisectionTest(unittest.TestCase): start, end, parallel, abs_path_to_src, test_pending_revisions, test_skip_revisions), []) - @mock.patch.object(LLVMHash, 'GetGitHashForVersion') + # Assume llvm_bisection module has imported GetGitHashFrom + @mock.patch.object(get_llvm_hash, 'GetGitHashFrom') def testSuccessfullyRetrievedRevisionsBetweenStartAndEnd( self, mock_get_git_hash): @@ -193,9 +195,10 @@ class LLVMBisectionTest(unittest.TestCase): self.assertEqual(mock_get_git_hash.call_count, 2) - # Simulate behavior of `GetGitHashForVersion()` when successfully retrieved + # Simulate behavior of `GetGitHashFrom()` when successfully retrieved # a list git hashes for each revision in the revisions list. - @mock.patch.object(LLVMHash, 'GetGitHashForVersion') + # Assume llvm_bisection module has imported GetGitHashFrom + @mock.patch.object(get_llvm_hash, 'GetGitHashFrom') # Simulate behavior of `GetRevisionsBetweenBisection()` when successfully # retrieved a list of valid revisions between 'start' and 'end'. @mock.patch.object(llvm_bisection, 'GetRevisionsBetweenBisection') @@ -216,7 +219,7 @@ class LLVMBisectionTest(unittest.TestCase): if call_count < 3: return expected_revisions_and_hash_tuple[1][call_count] - assert False, 'Called `GetGitHashForVersion()` more than expected.' + assert False, 'Called `GetGitHashFrom()` more than expected.' temp_worktree = '/abs/path/to/tmpDir' @@ -227,7 +230,7 @@ class LLVMBisectionTest(unittest.TestCase): mock_get_revisions_between_bisection.return_value = \ expected_revisions_and_hash_tuple[0] - # Simulate behavior of `GetGitHashForVersion()` by using the testing + # Simulate behavior of `GetGitHashFrom()` by using the testing # function. mock_get_git_hash.side_effect = MockGetGitHashForRevision @@ -370,10 +373,11 @@ class LLVMBisectionTest(unittest.TestCase): self.assertEqual(mock_add_tryjob.call_count, 3) - # Simulate behavior of `GetGitHashForVersion()` when successfully retrieved - # the git hash of the bad revision. + # Simulate behavior of `GetGitHashFrom()` when successfully retrieved + # the git hash of the bad revision. Assume llvm_bisection has imported + # GetGitHashFrom @mock.patch.object( - LLVMHash, 'GetGitHashForVersion', return_value='a123testhash4') + get_llvm_hash, 'GetGitHashFrom', return_value='a123testhash4') def testCompletedBisectionWhenProvidedSrcPath(self, mock_get_git_hash): last_tested = '/some/last/tested_file.json' diff --git a/llvm_tools/llvm_patch_management.py b/llvm_tools/llvm_patch_management.py index dff992a5..ef8b65c8 100755 --- a/llvm_tools/llvm_patch_management.py +++ b/llvm_tools/llvm_patch_management.py @@ -9,10 +9,10 @@ from __future__ import print_function import argparse +import get_llvm_hash import os -from pipes import quote - import patch_manager + from assert_not_in_chroot import VerifyOutsideChroot from failure_modes import FailureModes from get_llvm_hash import CreateTempLLVMRepo @@ -97,8 +97,8 @@ def GetCommandLineArgs(): # Duplicate packages were passed into the command line if len(unique_packages) != len(args_output.packages): - raise ValueError('Duplicate packages were passed in: %s' % - ' '.join(args_output.packages)) + raise ValueError('Duplicate packages were passed in: %s' % ' '.join( + args_output.packages)) args_output.packages = unique_packages @@ -212,7 +212,7 @@ def UpdatePackagesPatchMetadataFile(chroot_path, svn_version, with CreateTempLLVMRepo(temp_dir) as src_path: # Ensure that 'svn_version' exists in the chromiumum mirror of LLVM by # finding its corresponding git hash. - git_hash = llvm_hash.GetGitHashForVersion(src_path, svn_version) + git_hash = get_llvm_hash.GetGitHashFrom(src_path, svn_version) # Git hash of 'svn_version' exists, so move the source tree's HEAD to # 'git_hash' via `git checkout`. @@ -232,10 +232,8 @@ def UpdatePackagesPatchMetadataFile(chroot_path, svn_version, patch_manager.CleanSrcTree(src_path) # Get the patch results for the current package. - patches_info = patch_manager.HandlePatches(svn_version, - patch_metadata_path, - filesdir_path, src_path, - mode) + patches_info = patch_manager.HandlePatches( + svn_version, patch_metadata_path, filesdir_path, src_path, mode) package_info[cur_package] = patches_info._asdict() diff --git a/llvm_tools/llvm_patch_management_unittest.py b/llvm_tools/llvm_patch_management_unittest.py index c9bc7fce..75f003e9 100755 --- a/llvm_tools/llvm_patch_management_unittest.py +++ b/llvm_tools/llvm_patch_management_unittest.py @@ -7,16 +7,17 @@ """Unit tests when creating the arguments for the patch manager.""" from __future__ import print_function - from collections import namedtuple +from failure_modes import FailureModes + +import get_llvm_hash +import llvm_patch_management import os +import patch_manager +import subprocess import unittest import unittest.mock as mock -from failure_modes import FailureModes -from get_llvm_hash import LLVMHash -import llvm_patch_management -import patch_manager class LlvmPatchManagementTest(unittest.TestCase): @@ -142,10 +143,10 @@ class LlvmPatchManagementTest(unittest.TestCase): mock_isfile.assert_called_once() - # Simulate `GetGitHashForVersion()` when successfully retrieved the git hash + # Simulate `GetGitHashFrom()` when successfully retrieved the git hash # of the version passed in. @mock.patch.object( - LLVMHash, 'GetGitHashForVersion', return_value='a123testhash1') + get_llvm_hash, 'GetGitHashFrom', return_value='a123testhash1') # Simulate `CreateTempLLVMRepo()` when successfully created a work tree from # the LLVM repo copy in `llvm_tools` directory. @mock.patch.object(llvm_patch_management, 'CreateTempLLVMRepo') @@ -215,10 +216,10 @@ class LlvmPatchManagementTest(unittest.TestCase): # Simulate `CleanSrcTree()` when successfully removed changes from the # worktree. @mock.patch.object(patch_manager, 'CleanSrcTree') - # Simulate `GetGitHashForVersion()` when successfully retrieved the git hash + # Simulate `GetGitHashFrom()` when successfully retrieved the git hash # of the version passed in. @mock.patch.object( - LLVMHash, 'GetGitHashForVersion', return_value='a123testhash1') + get_llvm_hash, 'GetGitHashFrom', return_value='a123testhash1') # Simulate `CreateTempLLVMRepo()` when successfully created a work tree from # the LLVM repo copy in `llvm_tools` directory. @mock.patch.object(llvm_patch_management, 'CreateTempLLVMRepo') diff --git a/llvm_tools/patch_manager.py b/llvm_tools/patch_manager.py index 806b944f..c51ba200 100755 --- a/llvm_tools/patch_manager.py +++ b/llvm_tools/patch_manager.py @@ -147,14 +147,13 @@ def GetCommandLineArgs(): def GetHEADSVNVersion(src_path): """Gets the SVN version of HEAD in the src tree.""" - get_head_cmd = ['git', '-C', src_path, 'log', '-1', '--pretty=%B'] + cmd = ['git', '-C', src_path, 'rev-parse', 'HEAD'] - head_commit_message = check_output(get_head_cmd) + git_hash = check_output(cmd) - head_svn_version = LLVMHash().GetSVNVersionFromCommitMessage( - head_commit_message) + version = GetVersionFrom(src_path, git_hash) - return head_svn_version + return version def VerifyHEADIsTheSameAsSVNVersion(src_path, svn_version): @@ -282,11 +281,9 @@ def GetCommitHashesForBisection(src_path, good_svn_version, bad_svn_version): new_llvm_hash = LLVMHash() - bad_commit_hash = new_llvm_hash.GetGitHashForVersion(src_path, - bad_svn_version) + bad_commit_hash = get_llvm_hash.GetGitHashFrom(src_path, bad_svn_version) - good_commit_hash = new_llvm_hash.GetGitHashForVersion(src_path, - good_svn_version) + good_commit_hash = get_llvm_hash.GetGitHashFrom(src_path, good_svn_version) return good_commit_hash, bad_commit_hash @@ -295,13 +292,13 @@ def PerformBisection(src_path, good_commit, bad_commit, svn_version, patch_metadata_file, filesdir_path, num_patches): """Performs bisection to determine where a patch stops applying.""" - bisect_start_cmd = [ + start_cmd = [ 'git', '-C', src_path, 'bisect', 'start', bad_commit, good_commit ] - check_output(bisect_start_cmd) + check_output(start_cmd) - bisect_run_cmd = [ + run_cmd = [ 'git', '-C', src_path, 'bisect', 'run', os.path.abspath(__file__), '--svn_version', '%d' % svn_version, '--patch_metadata_file', patch_metadata_file, @@ -310,25 +307,24 @@ def PerformBisection(src_path, good_commit, bad_commit, svn_version, '%d' % num_patches ] - check_call(bisect_run_cmd) + check_call(run_cmd) # Successfully bisected the patch, so retrieve the SVN version from the # commit message. - get_bad_commit_from_bisect_run_cmd = [ - 'git', '-C', src_path, 'show', 'refs/bisect/bad' + get_bad_commit_hash_cmd = [ + 'git', '-C', src_path, 'rev-parse', 'refs/bisect/bad' ] - bad_commit_message = check_output(get_bad_commit_from_bisect_run_cmd) + git_hash = check_output(get_bad_commit_hash_cmd) - end_bisection_cmd = ['git', '-C', src_path, 'bisect', 'reset'] + end_cmd = ['git', '-C', src_path, 'bisect', 'reset'] - check_output(end_bisection_cmd) + check_output(end_cmd) # `git bisect run` returns the bad commit hash and the commit message. - bad_version = LLVMHash().GetSVNVersionFromCommitMessage( - bad_commit_message.rstrip()) + version = GetVersionFrom(src_path, git_hash) - return bad_version + return version def CleanSrcTree(src_path): -- cgit v1.2.3