| # Copyright 2018 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. |
| |
| """Creates a archive manifest used for Fuchsia package generation.""" |
| |
| import argparse |
| import json |
| import os |
| import re |
| import subprocess |
| import sys |
| import tempfile |
| |
| |
| def MakePackagePath(file_path, roots): |
| """Computes a path for |file_path| that is relative to one of the directory |
| paths in |roots|. |
| |
| file_path: The file path to relativize. |
| roots: A list of directory paths which may serve as a relative root |
| for |file_path|. |
| |
| Examples: |
| |
| >>> MakePackagePath('/foo/bar.txt', ['/foo/']) |
| 'bar.txt' |
| |
| >>> MakePackagePath('/foo/dir/bar.txt', ['/foo/']) |
| 'dir/bar.txt' |
| |
| >>> MakePackagePath('/foo/out/Debug/bar.exe', ['/foo/', '/foo/out/Debug/']) |
| 'bar.exe' |
| """ |
| |
| # Prevents greedily matching against a shallow path when a deeper, better |
| # matching path exists. |
| roots.sort(key=len, reverse=True) |
| |
| for next_root in roots: |
| if not next_root.endswith(os.sep): |
| next_root += os.sep |
| |
| if file_path.startswith(next_root): |
| relative_path = file_path[len(next_root):] |
| |
| return relative_path |
| |
| return file_path |
| |
| |
| def _GetStrippedPath(bin_path): |
| """Finds the stripped version of the binary |bin_path| in the build |
| output directory.""" |
| |
| return bin_path.replace('lib.unstripped/', 'lib/').replace( |
| 'exe.unstripped/', '') |
| |
| |
| def _IsBinary(path): |
| """Checks if the file at |path| is an ELF executable by inspecting its FourCC |
| header.""" |
| |
| with open(path, 'rb') as f: |
| file_tag = f.read(4) |
| return file_tag == '\x7fELF' |
| |
| |
| def _WriteBuildIdsTxt(binary_paths, ids_txt_path): |
| """Writes an index text file that maps build IDs to the paths of unstripped |
| binaries.""" |
| |
| READELF_FILE_PREFIX = 'File: ' |
| READELF_BUILD_ID_PREFIX = 'Build ID: ' |
| |
| # List of binaries whose build IDs are awaiting processing by readelf. |
| # Entries are removed as readelf's output is parsed. |
| unprocessed_binary_paths = {os.path.basename(p): p for p in binary_paths} |
| |
| with open(ids_txt_path, 'w') as ids_file: |
| readelf_stdout = subprocess.check_output( |
| ['readelf', '-n'] + map(_GetStrippedPath, binary_paths)) |
| |
| if len(binary_paths) == 1: |
| # Readelf won't report a binary's path if only one was provided to the |
| # tool. |
| binary_shortname = os.path.basename(binary_paths[0]) |
| else: |
| binary_shortname = None |
| |
| for line in readelf_stdout.split('\n'): |
| line = line.strip() |
| |
| if line.startswith(READELF_FILE_PREFIX): |
| binary_shortname = os.path.basename(line[len(READELF_FILE_PREFIX):]) |
| assert binary_shortname in unprocessed_binary_paths |
| |
| elif line.startswith(READELF_BUILD_ID_PREFIX): |
| # Paths to the unstripped executables listed in "ids.txt" are specified |
| # as relative paths to that file. |
| unstripped_rel_path = os.path.relpath( |
| os.path.abspath(unprocessed_binary_paths[binary_shortname]), |
| os.path.dirname(os.path.abspath(ids_txt_path))) |
| |
| build_id = line[len(READELF_BUILD_ID_PREFIX):] |
| ids_file.write(build_id + ' ' + unstripped_rel_path + '\n') |
| del unprocessed_binary_paths[binary_shortname] |
| |
| # Did readelf forget anything? Make sure that all binaries are accounted for. |
| assert not unprocessed_binary_paths |
| |
| |
| def BuildManifest(args): |
| binaries = [] |
| with open(args.manifest_path, 'w') as manifest, \ |
| open(args.depfile_path, 'w') as depfile: |
| # Process the runtime deps file for file paths, recursively walking |
| # directories as needed. |
| # MakePackagePath() may relativize to either the source root or output |
| # directory. |
| # runtime_deps may contain duplicate paths, so use a set for |
| # de-duplication. |
| expanded_files = set() |
| for next_path in open(args.runtime_deps_file, 'r'): |
| next_path = next_path.strip() |
| if os.path.isdir(next_path): |
| for root, _, files in os.walk(next_path): |
| for current_file in files: |
| if current_file.startswith('.'): |
| continue |
| expanded_files.add( |
| os.path.join(root, current_file)) |
| else: |
| expanded_files.add(next_path) |
| |
| # Format and write out the manifest contents. |
| gen_dir = os.path.normpath(os.path.join(args.out_dir, "gen")) |
| app_found = False |
| excluded_files_set = set(args.exclude_file) |
| for current_file in expanded_files: |
| if _IsBinary(current_file): |
| binaries.append(current_file) |
| current_file = _GetStrippedPath(current_file) |
| |
| in_package_path = MakePackagePath(current_file, |
| [gen_dir, args.root_dir, args.out_dir]) |
| if in_package_path == args.app_filename: |
| app_found = True |
| |
| if in_package_path in excluded_files_set: |
| excluded_files_set.remove(in_package_path) |
| continue |
| |
| manifest.write('%s=%s\n' % (in_package_path, current_file)) |
| |
| if len(excluded_files_set) > 0: |
| raise Exception('Some files were excluded with --exclude-file, but ' |
| 'not found in the deps list: %s' % |
| ', '.join(excluded_files_set)); |
| |
| if not app_found: |
| raise Exception('Could not locate executable inside runtime_deps.') |
| |
| # Write meta/package manifest file. |
| with open(os.path.join(os.path.dirname(args.manifest_path), 'package'), |
| 'w') as package_json: |
| json.dump({'version': '0', 'name': args.app_name}, package_json) |
| manifest.write('meta/package=%s\n' % |
| os.path.relpath(package_json.name, args.out_dir)) |
| |
| # Write component manifest file. |
| cmx_file_path = os.path.join(os.path.dirname(args.manifest_path), |
| args.app_name + '.cmx') |
| with open(cmx_file_path, 'w') as component_manifest_file: |
| component_manifest = { |
| 'program': { 'binary': args.app_filename }, |
| 'sandbox': json.load(open(args.sandbox_policy_path, 'r')), |
| } |
| json.dump(component_manifest, component_manifest_file) |
| |
| manifest.write('meta/%s=%s\n' % |
| (os.path.basename(component_manifest_file.name), |
| os.path.relpath(cmx_file_path, args.out_dir))) |
| |
| depfile.write( |
| "%s: %s" % (os.path.relpath(args.manifest_path, args.out_dir), |
| " ".join([os.path.relpath(f, args.out_dir) |
| for f in expanded_files]))) |
| |
| _WriteBuildIdsTxt(binaries, args.build_ids_file) |
| |
| return 0 |
| |
| |
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument('--root-dir', required=True, help='Build root directory') |
| parser.add_argument('--out-dir', required=True, help='Build output directory') |
| parser.add_argument('--app-name', required=True, help='Package name') |
| parser.add_argument('--app-filename', required=True, |
| help='Path to the main application binary relative to the output dir.') |
| parser.add_argument('--sandbox-policy-path', required=True, |
| help='Path to the sandbox policy file relative to the output dir.') |
| parser.add_argument('--runtime-deps-file', required=True, |
| help='File with the list of runtime dependencies.') |
| parser.add_argument('--depfile-path', required=True, |
| help='Path to write GN deps file.') |
| parser.add_argument('--exclude-file', action='append', default=[], |
| help='Package-relative file path to exclude from the package.') |
| parser.add_argument('--manifest-path', required=True, |
| help='Manifest output path.') |
| parser.add_argument('--build-ids-file', required=True, |
| help='Debug symbol index path.') |
| |
| args = parser.parse_args() |
| |
| return BuildManifest(args) |
| |
| if __name__ == '__main__': |
| sys.exit(main()) |
