| #!/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. | |
| import os | |
| import platform | |
| import shutil | |
| import subprocess | |
| import sys | |
| def assert_directory(path, what): | |
| """Logs an error and exits with EX_NOINPUT if the specified directory doesn't exist.""" | |
| if not os.path.isdir(path): | |
| log_error('Cannot find %s at %s' % (what, path)) | |
| sys.exit(os.EX_NOINPUT) | |
| def assert_file(path, what): | |
| """Logs an error and exits with EX_NOINPUT if the specified file doesn't exist.""" | |
| if not os.path.isfile(path): | |
| log_error('Cannot find %s at %s' % (what, path)) | |
| sys.exit(os.EX_NOINPUT) | |
| def assert_valid_codesign_config( | |
| framework_dir, zip_contents, entitlements, without_entitlements, unsigned_binaries | |
| ): | |
| """Exits with exit code 1 if the codesign configuration contents are incorrect. | |
| All Mach-O binaries found within zip_contents exactly must be listed in | |
| either entitlements or without_entitlements.""" | |
| if _contains_duplicates(entitlements): | |
| log_error('ERROR: duplicate value(s) found in entitlements.txt') | |
| log_error_items(sorted(entitlements)) | |
| sys.exit(os.EX_DATAERR) | |
| if _contains_duplicates(without_entitlements): | |
| log_error('ERROR: duplicate value(s) found in without_entitlements.txt') | |
| log_error_items(sorted(without_entitlements)) | |
| sys.exit(os.EX_DATAERR) | |
| if _contains_duplicates(unsigned_binaries): | |
| log_error('ERROR: duplicate value(s) found in unsigned_binaries.txt') | |
| log_error_items(sorted(unsigned_binaries)) | |
| sys.exit(os.EX_DATAERR) | |
| if _contains_duplicates(entitlements + without_entitlements + unsigned_binaries): | |
| log_error( | |
| 'ERROR: duplicate value(s) found between ' | |
| 'entitlements.txt, without_entitlements.txt, unsigned_binaries.txt' | |
| ) | |
| log_error_items(sorted(entitlements + without_entitlements + unsigned_binaries)) | |
| sys.exit(os.EX_DATAERR) | |
| binaries = set() | |
| for zip_content_path in zip_contents: | |
| # If file, check if Mach-O binary. | |
| if _is_macho_binary(os.path.join(framework_dir, zip_content_path)): | |
| binaries.add(zip_content_path) | |
| # If directory, check transitive closure of files for Mach-O binaries. | |
| for root, _, files in os.walk(os.path.join(framework_dir, zip_content_path)): | |
| for file in [os.path.join(root, f) for f in files]: | |
| if _is_macho_binary(file): | |
| binaries.add(os.path.relpath(file, framework_dir)) | |
| # Verify that all Mach-O binaries are listed in either entitlements, | |
| # without_entitlements, or unsigned_binaries. | |
| listed_binaries = set(entitlements + without_entitlements + unsigned_binaries) | |
| if listed_binaries != binaries: | |
| log_error( | |
| 'ERROR: binaries listed in entitlements.txt, without_entitlements.txt, and' | |
| 'unsigned_binaries.txt do not match the set of binaries in the files to be zipped' | |
| ) | |
| log_error('Binaries found in files to be zipped:') | |
| for file in sorted(binaries): | |
| log_error(' ' + file) | |
| not_listed = sorted(binaries - listed_binaries) | |
| if not_listed: | |
| log_error( | |
| 'Binaries NOT LISTED in entitlements.txt, without_entitlements.txt, ' | |
| 'unsigned_binaries.txt:' | |
| ) | |
| for file in not_listed: | |
| log_error(' ' + file) | |
| not_found = sorted(listed_binaries - binaries) | |
| if not_found: | |
| log_error( | |
| 'Binaries listed in entitlements.txt, without_entitlements.txt, ' | |
| 'unsigned_binaries.txt but NOT FOUND:' | |
| ) | |
| for file in not_found: | |
| log_error(' ' + file) | |
| sys.exit(os.EX_NOINPUT) | |
| def _contains_duplicates(strings): | |
| """Returns true if the list of strings contains a duplicate value.""" | |
| return len(strings) != len(set(strings)) | |
| def _is_macho_binary(filename): | |
| """Returns True if the specified path is file and a Mach-O binary.""" | |
| if os.path.islink(filename) or not os.path.isfile(filename): | |
| return False | |
| with open(filename, 'rb') as file: | |
| chunk = file.read(4) | |
| return chunk in ( | |
| b'\xca\xfe\xba\xbe', # Mach-O Universal Big Endian | |
| b'\xce\xfa\xed\xfe', # Mach-O Little Endian (32-bit) | |
| b'\xcf\xfa\xed\xfe', # Mach-O Little Endian (64-bit) | |
| b'\xfe\xed\xfa\xce', # Mach-O Big Endian (32-bit) | |
| b'\xfe\xed\xfa\xcf', # Mach-O Big Endian (64-bit) | |
| ) | |
| def buildroot_relative_path(path): | |
| """Returns the absolute path to the specified buildroot-relative path.""" | |
| buildroot_dir = os.path.abspath(os.path.join(os.path.realpath(__file__), '..', '..', '..', '..')) | |
| return os.path.join(buildroot_dir, path) | |
| def copy_binary(source_path, destination_path): | |
| """Copies a binary, preserving POSIX permissions.""" | |
| assert_file(source_path, 'file to copy') | |
| shutil.copy2(source_path, destination_path) | |
| def copy_tree(source_path, destination_path, symlinks=False): | |
| """Performs a recursive copy of a directory. If the destination path is | |
| present, it is deleted first.""" | |
| assert_directory(source_path, 'directory to copy') | |
| shutil.rmtree(destination_path, True) | |
| shutil.copytree(source_path, destination_path, symlinks=symlinks) | |
| def create_fat_macos_framework(args, dst, fat_framework, arm64_framework, x64_framework): | |
| """Creates a fat framework from two arm64 and x64 frameworks.""" | |
| # Clone the arm64 framework bundle as a starting point. | |
| copy_tree(arm64_framework, fat_framework, symlinks=True) | |
| _regenerate_symlinks(fat_framework) | |
| framework_dylib = get_mac_framework_dylib_path(fat_framework) | |
| lipo([get_mac_framework_dylib_path(arm64_framework), | |
| get_mac_framework_dylib_path(x64_framework)], framework_dylib) | |
| _set_framework_permissions(fat_framework) | |
| framework_dsym = fat_framework + '.dSYM' if args.dsym else None | |
| _process_macos_framework(args, dst, framework_dylib, framework_dsym) | |
| def _regenerate_symlinks(framework_dir): | |
| """Regenerates the framework symlink structure. | |
| When building on the bots, the framework is produced in one shard, uploaded | |
| to LUCI's content-addressable storage cache (CAS), then pulled down in | |
| another shard. When that happens, symlinks are dereferenced, resulting a | |
| corrupted framework. This regenerates the expected symlink farm. | |
| """ | |
| # If the dylib is symlinked, assume symlinks are all fine and bail out. | |
| # The shutil.rmtree calls below only work on directories, and fail on symlinks. | |
| framework_name = get_framework_name(framework_dir) | |
| if os.path.islink(os.path.join(framework_dir, framework_name)): | |
| return | |
| # Delete any existing files/directories. | |
| os.remove(os.path.join(framework_dir, framework_name)) | |
| shutil.rmtree(os.path.join(framework_dir, 'Headers'), True) | |
| shutil.rmtree(os.path.join(framework_dir, 'Modules'), True) | |
| shutil.rmtree(os.path.join(framework_dir, 'Resources'), True) | |
| current_version_path = os.path.join(framework_dir, 'Versions', 'Current') | |
| shutil.rmtree(current_version_path, True) | |
| # Recreate the expected framework symlinks. | |
| os.symlink('A', current_version_path) | |
| os.symlink( | |
| os.path.join('Versions', 'Current', framework_name), | |
| os.path.join(framework_dir, framework_name) | |
| ) | |
| os.symlink(os.path.join('Versions', 'Current', 'Headers'), os.path.join(framework_dir, 'Headers')) | |
| os.symlink(os.path.join('Versions', 'Current', 'Modules'), os.path.join(framework_dir, 'Modules')) | |
| os.symlink( | |
| os.path.join('Versions', 'Current', 'Resources'), os.path.join(framework_dir, 'Resources') | |
| ) | |
| def _set_framework_permissions(framework_dir): | |
| """Sets framework contents to be world readable, and world executable if user-executable.""" | |
| # Make the framework readable and executable: u=rwx,go=rx. | |
| subprocess.check_call(['chmod', '755', framework_dir]) | |
| # Add group and other readability to all files. | |
| versions_path = os.path.join(framework_dir, 'Versions') | |
| subprocess.check_call(['chmod', '-R', 'og+r', versions_path]) | |
| # Find all the files below the target dir with owner execute permission | |
| find_subprocess = subprocess.Popen(['find', versions_path, '-perm', '-100', '-print0'], | |
| stdout=subprocess.PIPE) | |
| # Add execute permission for other and group for all files that had it for owner. | |
| xargs_subprocess = subprocess.Popen(['xargs', '-0', 'chmod', 'og+x'], | |
| stdin=find_subprocess.stdout) | |
| find_subprocess.wait() | |
| xargs_subprocess.wait() | |
| def _process_macos_framework(args, dst, framework_dylib, dsym): | |
| if dsym: | |
| extract_dsym(framework_dylib, dsym) | |
| if args.strip: | |
| unstripped_out = os.path.join(dst, 'FlutterMacOS.unstripped') | |
| strip_binary(framework_dylib, unstripped_out) | |
| def create_zip(cwd, zip_filename, paths): | |
| """Creates a zip archive in cwd, containing a set of cwd-relative files. | |
| In order to preserve the correct internal structure of macOS frameworks, | |
| symlinks are preserved (-y). In order to generate reproducible builds, | |
| owner/group and unix file timestamps are not included in the archive (-X). | |
| """ | |
| subprocess.check_call(['zip', '-r', '-X', '-y', zip_filename] + paths, cwd=cwd) | |
| def _dsymutil_path(): | |
| """Returns the path to dsymutil within Flutter's clang toolchain.""" | |
| arch_subpath = 'mac-arm64' if platform.processor() == 'arm' else 'mac-x64' | |
| dsymutil_path = os.path.join('flutter', 'buildtools', arch_subpath, 'clang', 'bin', 'dsymutil') | |
| return buildroot_relative_path(dsymutil_path) | |
| def get_framework_name(framework_dir): | |
| """Returns Foo given /path/to/Foo.framework.""" | |
| return os.path.splitext(os.path.basename(framework_dir))[0] | |
| def get_mac_framework_dylib_path(framework_dir): | |
| """Returns /path/to/Foo.framework/Versions/A/Foo given /path/to/Foo.framework.""" | |
| return os.path.join(framework_dir, 'Versions', 'A', get_framework_name(framework_dir)) | |
| def extract_dsym(binary_path, dsym_out_path): | |
| """Extracts a dSYM bundle from the specified Mach-O binary.""" | |
| arch_dir = 'mac-arm64' if platform.processor() == 'arm' else 'mac-x64' | |
| dsymutil = buildroot_relative_path( | |
| os.path.join('flutter', 'buildtools', arch_dir, 'clang', 'bin', 'dsymutil') | |
| ) | |
| subprocess.check_call([dsymutil, '-o', dsym_out_path, binary_path]) | |
| def lipo(input_binaries, output_binary): | |
| """Uses lipo to create a fat binary from a set of input binaries.""" | |
| subprocess.check_call(['lipo'] + input_binaries + ['-create', '-output', output_binary]) | |
| def log_error(message): | |
| """Writes the message to stderr, followed by a newline.""" | |
| print(message, file=sys.stderr) | |
| def log_error_items(items): | |
| """Writes each item indented to stderr, followed by a newline.""" | |
| for item in items: | |
| log_error(' ' + item) | |
| def strip_binary(binary_path, unstripped_copy_path): | |
| """Makes a copy of an unstripped binary, then strips symbols from the binary.""" | |
| assert_file(binary_path, 'binary to strip') | |
| shutil.copyfile(binary_path, unstripped_copy_path) | |
| subprocess.check_call(['strip', '-x', '-S', binary_path]) | |
| def write_codesign_config(output_path, paths): | |
| """Writes an Apple codesign configuration file containing the specified paths.""" | |
| with open(output_path, mode='w', encoding='utf-8') as file: | |
| if paths: | |
| file.write('\n'.join(paths) + '\n') |