blob: 930e45fc88351019d9952ea2802cd587e3a03ca5 [file] [log] [blame]
#!/usr/bin/env python3
# Copyright 2013 The Flutter Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
#
# Derivative work of https://chromium.googlesource.com/chromium/src/+/HEAD/build/config/fuchsia/prepare_package_inputs.py
#
"""Creates a archive manifest used for Fuchsia package generation."""
import argparse
import json
import os
import shutil
import subprocess
import sys
# File extension of a component manifest for each Component Framework version
MANIFEST_VERSION_EXTENSIONS = {"v1": ".cmx", "v2": ".cm"}
def make_package_path(file_path, roots):
"""Computes a path for |file_path| relative to one of the |roots|.
Args:
file_path: The file path to relativize.
roots: A list of directory paths which may serve as a relative root for
|file_path|.
For example:
* make_package_path('/foo/bar.txt', ['/foo/']) 'bar.txt'
* make_package_path('/foo/dir/bar.txt', ['/foo/']) 'dir/bar.txt'
* make_package_path('/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 _get_stripped_path(bin_path):
"""Finds the stripped version of |bin_path| in the build output directory.
returns |bin_path| if no stripped path is found.
"""
stripped_path = bin_path.replace('lib.unstripped/',
'lib/').replace('exe.unstripped/', '')
if os.path.exists(stripped_path):
return stripped_path
else:
return bin_path
def _is_binary(path):
"""Checks if the file at |path| is an ELF executable.
This is done by inspecting its FourCC header.
"""
with open(path, 'rb') as f:
file_tag = f.read(4)
return file_tag == b'\x7fELF'
def _write_build_ids_txt(binary_paths, ids_txt_path):
"""Writes an index text file mapping build IDs to 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 = set(binary_paths)
build_ids_map = {}
# Sanity check that unstripped binaries do not also have their stripped
# counterpart listed.
for binary_path in binary_paths:
stripped_binary_path = _get_stripped_path(binary_path)
if stripped_binary_path != binary_path:
unprocessed_binary_paths.discard(stripped_binary_path)
with open(ids_txt_path, 'w') as ids_file:
# TODO(richkadel): This script (originally from the Fuchsia GN SDK) was
# changed, adding this `if unprocessed_binary_paths` check, because for
# the Dart packages I tested (child-view and parent-view), this was
# empty. Update the Fuchsia GN SDK? (Or figure out if the Dart packages
# _should_ have at least one unprocessed_binary_path?)
if unprocessed_binary_paths:
# Create a set to dedupe stripped binary paths in case both the stripped and
# unstripped versions of a binary are specified.
readelf_stdout = subprocess.check_output(['readelf', '-n'] +
sorted(unprocessed_binary_paths)
).decode('utf8')
if len(binary_paths) == 1:
# Readelf won't report a binary's path if only one was provided to the
# tool.
binary_path = binary_paths[0]
else:
binary_path = None
for line in readelf_stdout.split('\n'):
line = line.strip()
if line.startswith(READELF_FILE_PREFIX):
binary_path = line[len(READELF_FILE_PREFIX):]
assert binary_path 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(binary_path),
os.path.dirname(os.path.abspath(ids_txt_path))
)
build_id = line[len(READELF_BUILD_ID_PREFIX):]
build_ids_map[build_id] = unstripped_rel_path
unprocessed_binary_paths.remove(binary_path)
for id_and_path in sorted(build_ids_map.items()):
ids_file.write(id_and_path[0] + ' ' + id_and_path[1] + '\n')
# Did readelf forget anything? Make sure that all binaries are accounted for.
assert not unprocessed_binary_paths
def _parse_component(component_info_file):
component_info = json.load(open(component_info_file, 'r'))
return component_info
def _get_component_manifests(component_info):
return [c for c in component_info if c.get('type') == 'manifest']
# TODO(richkadel): Changed, from the Fuchsia GN SDK version to add this function
# and related code, to include support for a file of resources that aren't known
# until compile time.
def _get_resource_items_from_json_items(component_info):
nested_resources = []
files = [
c.get('source')
for c in component_info
if c.get('type') == 'json_of_resources'
]
for json_file in files:
for resource in _parse_component(json_file):
nested_resources.append(resource)
return nested_resources
def _get_resource_items(component_info):
return ([c for c in component_info if c.get('type') == 'resource'] +
_get_resource_items_from_json_items(component_info))
def _get_expanded_files(runtime_deps_file):
""" Process the runtime deps file for file paths, recursively walking
directories as needed.
Returns a set of expanded files referenced by the runtime deps file.
"""
# runtime_deps may contain duplicate paths, so use a set for
# de-duplication.
expanded_files = set()
for next_path in open(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.normpath(os.path.join(root, current_file)))
else:
expanded_files.add(os.path.normpath(next_path))
return expanded_files
def _write_gn_deps_file(
depfile_path, package_manifest, component_manifests, out_dir, expanded_files
):
with open(depfile_path, 'w') as depfile:
deps_list = [os.path.relpath(f, out_dir) for f in expanded_files]
deps_list.extend(component_manifests)
# The deps file is space-delimited, so filenames containing spaces
# must have them escaped.
deps_list = [f.replace(' ', '\\ ') for f in deps_list]
deps_string = ' '.join(sorted(deps_list))
depfile.write('%s: %s' % (package_manifest, deps_string))
def _write_meta_package_manifest(
manifest_entries, manifest_path, app_name, out_dir, package_version
):
# Write meta/package manifest file and add to archive manifest.
meta_package = os.path.join(os.path.dirname(manifest_path), 'package')
with open(meta_package, 'w') as package_json:
json_payload = {'version': package_version, 'name': app_name}
json.dump(json_payload, package_json)
package_json_filepath = os.path.relpath(package_json.name, out_dir)
manifest_entries['meta/package'] = package_json_filepath
def _write_component_manifest(
manifest_entries, component_info, archive_manifest_path, out_dir
):
"""Copy component manifest files and add to archive manifest.
Raises an exception if a component uses a unknown manifest version.
"""
for component_manifest in _get_component_manifests(component_info):
manifest_version = component_manifest.get('manifest_version')
if manifest_version not in MANIFEST_VERSION_EXTENSIONS:
raise Exception('Unknown manifest_version: {}'.format(manifest_version))
# TODO(richkadel): Changed, from the Fuchsia GN SDK version, to assume
# the given `output_name` already includes its extension. This change
# has not been fully validate, in particular, it has not been tested
# with CF v2 `.cm` (from `.cml`) files. Original implementation was:
#
# extension = MANIFEST_VERSION_EXTENSIONS.get(manifest_version)
# manifest_dest_file_path = os.path.join(
# os.path.dirname(archive_manifest_path),
# component_manifest.get('output_name') + extension)
manifest_dest_file_path = os.path.join(
os.path.dirname(archive_manifest_path),
component_manifest.get('output_name')
)
# Add the 'meta/' subdir, for example, if `output_name` includes it
os.makedirs(os.path.dirname(manifest_dest_file_path), exist_ok=True)
shutil.copy(component_manifest.get('source'), manifest_dest_file_path)
manifest_entries['meta/%s' % os.path.basename(manifest_dest_file_path)
] = os.path.relpath(manifest_dest_file_path, out_dir)
return manifest_dest_file_path
def _write_package_manifest(
manifest_entries, expanded_files, out_dir, exclude_file, root_dir,
component_info
):
"""Writes the package manifest for a Fuchsia package
Returns a list of binaries in the package.
Raises an exception if excluded files are not found."""
gen_dir = os.path.normpath(os.path.join(out_dir, 'gen'))
excluded_files_set = set(exclude_file)
roots = [gen_dir, root_dir, out_dir]
# Filter out component manifests. These are written out elsewhere.
excluded_files_set.update([
make_package_path(os.path.relpath(cf.get('source'), out_dir), roots)
for cf in _get_component_manifests(component_info)
if os.path.relpath(cf.get('source'), out_dir) in expanded_files
])
# Filter out json_of_resources since only their contents are written, and we
# don't know the contained resources until late in the build cycle
excluded_files_set.update([
make_package_path(os.path.relpath(cf.get('source'), out_dir), roots)
for cf in component_info
if cf.get('type') == 'json_of_resources' and
os.path.relpath(cf.get('source'), out_dir) in expanded_files
])
# Write out resource files with specific package paths, and exclude them from
# the list of expanded files so they are not listed twice in the manifest.
for resource in _get_resource_items(component_info):
relative_src_file = os.path.relpath(resource.get('source'), out_dir)
resource_path = make_package_path(relative_src_file, roots)
manifest_entries[resource.get('dest')] = relative_src_file
if resource.get('type') == 'resource':
excluded_files_set.add(resource_path)
for current_file in expanded_files:
current_file = _get_stripped_path(current_file)
# make_package_path() may relativize to either the source root or
# output directory.
in_package_path = make_package_path(current_file, roots)
if in_package_path in excluded_files_set:
excluded_files_set.remove(in_package_path)
else:
manifest_entries[in_package_path] = current_file
if excluded_files_set:
raise Exception(
'Some files were excluded with --exclude-file but '
'not found in the deps list, or a resource (data) file '
'was added and not filtered out. Excluded files and resources: '
'%s' % ', '.join(excluded_files_set)
)
def _build_manifest(args):
# Use a sorted list to make sure the manifest order is deterministic.
expanded_files = sorted(_get_expanded_files(args.runtime_deps_file))
component_info = _parse_component(args.json_file)
component_manifests = []
# Collect the manifest entries in a map since duplication happens
# because of runtime libraries.
manifest_entries = {}
_write_meta_package_manifest(
manifest_entries, args.manifest_path, args.app_name, args.out_dir,
args.package_version
)
for component_item in component_info:
_write_package_manifest(
manifest_entries, expanded_files, args.out_dir, args.exclude_file,
args.root_dir, component_item
)
component_manifests.append(
_write_component_manifest(
manifest_entries, component_item, args.manifest_path, args.out_dir
)
)
with open(args.manifest_path, 'w') as manifest:
for key in sorted(manifest_entries.keys()):
manifest.write('%s=%s\n' % (key, manifest_entries[key]))
binaries = [f for f in expanded_files if _is_binary(f)]
_write_build_ids_txt(sorted(binaries), args.build_ids_file)
# Omit any excluded_files from the expanded_files written to the depfile.
gen_dir = os.path.normpath(os.path.join(args.out_dir, 'gen'))
roots = [gen_dir, args.root_dir, args.out_dir]
excluded_files_set = set(args.exclude_file)
expanded_deps_files = [
path for path in expanded_files
if make_package_path(path, roots) not in excluded_files_set
]
_write_gn_deps_file(
args.depfile_path, args.manifest_path, component_manifests, args.out_dir,
expanded_deps_files
)
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(
'--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.'
)
parser.add_argument('--json-file', required=True)
parser.add_argument(
'--package-version', default='0', help='Version of the package'
)
args = parser.parse_args()
return _build_manifest(args)
if __name__ == '__main__':
sys.exit(main())