From a12ddc6ec6dae22293f016664dacc48f5e93e18a Mon Sep 17 00:00:00 2001 From: dan sinclair Date: Tue, 19 Apr 2022 19:27:08 +0000 Subject: [PATCH] Updates to dawn_version_generator. This CL fixes the incorrect `path` variable used when the HEAD lookup fails, the proper path is now emitted. The call to `get_gitResolvedHead` is wrapped in a try/except and an exception is treated as if we are not in a git directory. This allows the build to continue if `refs/head/main` doesn't exist in the local check. Change-Id: I49ae66cc5eac99d43387b58d28d356282b8f6783 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/87100 Reviewed-by: Ben Clayton Reviewed-by: Corentin Wallez Commit-Queue: Dan Sinclair Auto-Submit: Dan Sinclair --- generator/dawn_version_generator.py | 59 ++++++++++++++++------------- 1 file changed, 33 insertions(+), 26 deletions(-) diff --git a/generator/dawn_version_generator.py b/generator/dawn_version_generator.py index 1907e88da4..8ee856a546 100644 --- a/generator/dawn_version_generator.py +++ b/generator/dawn_version_generator.py @@ -19,22 +19,22 @@ from generator_lib import Generator, run_generator, FileRender def get_git(): - return 'git.bat' if sys.platform == 'win32' else 'git' + return "git.bat" if sys.platform == "win32" else "git" def get_gitHash(dawnDir): - result = subprocess.run([get_git(), 'rev-parse', 'HEAD'], + result = subprocess.run([get_git(), "rev-parse", "HEAD"], stdout=subprocess.PIPE, cwd=dawnDir) if result.returncode == 0: - return result.stdout.decode('utf-8').strip() + return result.stdout.decode("utf-8").strip() # No hash was available (possibly) because the directory was not a git checkout. Dawn should # explicitly handle its absenece and disable features relying on the hash, i.e. caching. - return '' + return "" def get_gitHead(dawnDir): - return os.path.join(dawnDir, '.git', 'HEAD') + return os.path.join(dawnDir, ".git", "HEAD") def gitExists(dawnDir): @@ -43,71 +43,78 @@ def gitExists(dawnDir): def unpackGitRef(packed, resolved): with open(packed) as fin: - refs = fin.read().strip().split('\n') + refs = fin.read().strip().split("\n") # Strip comments - refs = [ref.split(' ') for ref in refs if ref.strip()[0] != '#'] + refs = [ref.split(" ") for ref in refs if ref.strip()[0] != "#"] # Parse results which are in the format [, ] from previous step. refs = [gitHash for (gitHash, refFile) in refs if refFile == resolved] if len(refs) == 1: - with open(resolved, 'w') as fout: - fout.write(refs[0] + '\n') + with open(resolved, "w") as fout: + fout.write(refs[0] + "\n") return True return False def get_gitResolvedHead(dawnDir): result = subprocess.run( - [get_git(), 'rev-parse', '--symbolic-full-name', 'HEAD'], + [get_git(), "rev-parse", "--symbolic-full-name", "HEAD"], stdout=subprocess.PIPE, - cwd=dawnDir) + cwd=dawnDir, + ) if result.returncode != 0: - raise Exception('Failed to execute git rev-parse to resolve git head.') + raise Exception("Failed to execute git rev-parse to resolve git head.") - resolved = os.path.join(dawnDir, '.git', - result.stdout.decode('utf-8').strip()) + resolved = os.path.join(dawnDir, ".git", + result.stdout.decode("utf-8").strip()) # Check a packed-refs file exists. If so, we need to potentially unpack and include it as a dep. - packed = os.path.join(dawnDir, '.git', 'packed-refs') + packed = os.path.join(dawnDir, ".git", "packed-refs") if os.path.exists(packed) and unpackGitRef(packed, resolved): return [packed, resolved] if not os.path.exists(resolved): - raise Exception('Unable to resolve git HEAD hash file:', path) + raise Exception("Unable to resolve git HEAD hash file:", resolved) return [resolved] def compute_params(args): return { - 'get_gitHash': lambda: get_gitHash(os.path.abspath(args.dawn_dir)), + "get_gitHash": lambda: get_gitHash(os.path.abspath(args.dawn_dir)), } class DawnVersionGenerator(Generator): def get_description(self): - return 'Generates version dependent Dawn code. Currently regenerated dependent on git hash.' + return "Generates version dependent Dawn code. Currently regenerated dependent on git hash." def add_commandline_arguments(self, parser): - parser.add_argument('--dawn-dir', - required=True, - type=str, - help='The Dawn root directory path to use') + parser.add_argument( + "--dawn-dir", + required=True, + type=str, + help="The Dawn root directory path to use", + ) def get_dependencies(self, args): dawnDir = os.path.abspath(args.dawn_dir) if gitExists(dawnDir): - return [get_gitHead(dawnDir)] + get_gitResolvedHead(dawnDir) + try: + return [get_gitHead(dawnDir)] + get_gitResolvedHead(dawnDir) + except Exception as e: + print(e) + return [] return [] def get_file_renders(self, args): params = compute_params(args) return [ - FileRender('dawn/common/Version.h', - 'src/dawn/common/Version_autogen.h', [params]), + FileRender("dawn/common/Version.h", + "src/dawn/common/Version_autogen.h", [params]), ] -if __name__ == '__main__': +if __name__ == "__main__": sys.exit(run_generator(DawnVersionGenerator()))