blob: 892130f637c39936630889e617696da695ecdecf [file] [log] [blame]
#!/usr/bin/env python
# coding: utf-8
# Copyright 2020 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.
import argparse
import errno
import filecmp
import os
import plistlib
import shutil
import stat
import subprocess
import sys
import time
def _stat_or_none(path, root):
"""Calls os.stat or os.lstat to obtain information about a path.
This program traverses parallel directory trees, which may have subtle
differences such as directory entries that are present in fewer than all
trees. It also operates on symbolic links directly, instead of on their
path: The path to call os.stat or os.lstat on.
root: True if called on the root of a tree to be merged, False
otherwise. See the discussion below.
The return value of os.stat or os.lstat, or possibly None if the path
does not exist.
When root is True, indicating that path is at the root of one of these
trees, this permissiveness is disabled, as all roots are required to be
present. If one is absent, an exception will be raised. When root is True,
os.stat will be used, as this is the one case when it is desirable to
operate on a symbolic link’s target.
When root is False, os.lstat will be used to operate on symbolic links
directly, and a missing path will cause None to be returned.
if root:
return os.stat(path)
return os.lstat(path)
except OSError as e:
if e.errno == errno.ENOENT:
return None
def _file_type_for_stat(st):
"""Returns a string indicating the type of directory entry in st.
st: The return value of os.stat or os.lstat.
'symbolic link', 'file', or 'directory'.
if stat.S_ISLNK(st.st_mode):
return 'symbolic_link'
if stat.S_ISREG(st.st_mode):
return 'file'
if stat.S_ISDIR(st.st_mode):
return 'directory'
raise Exception('unknown file type for mode 0o%o' % mode)
def _sole_list_element(l, exception_message):
"""Assures that every element in a list is identical.
l: The list to consider.
exception_message: A message used to convey failure if every element in
l is not identical.
The value of each identical element in the list.
s = set(l)
if len(s) != 1:
raise Exception(exception_message)
return l[0]
def _read_plist(path):
"""Reads a macOS property list, API compatibility adapter."""
with open(path, 'rb') as file:
# New API, available since Python 3.4.
return plistlib.load(file)
except AttributeError:
# Old API, available (but deprecated) until Python 3.9.
return plistlib.readPlist(file)
def _write_plist(value, path):
"""Writes a macOS property list, API compatibility adapter."""
with open(path, 'wb') as file:
# New API, available since Python 3.4.
plistlib.dump(value, file)
except AttributeError:
# Old API, available (but deprecated) until Python 3.9.
plistlib.writePlist(value, file)
class CantMergeException(Exception):
"""Raised when differences exist between input files such that they cannot
be merged successfully.
def _merge_info_plists(input_paths, output_path):
"""Merges multiple macOS Info.plist files.
input_plists: A list of paths containing Info.plist files to be merged.
output_plist: The path of the merged Info.plist to create.
CantMergeException if all input_paths could not successfully be merged
into output_path.
A small number of differences are tolerated in the input Info.plists. If a
key identifying the build environment (OS or toolchain) is different in any
of the inputs, it will be removed from the output. There are valid reasons
to produce builds for different architectures using different toolchains or
SDKs, and there is no way to rationalize these differences into a single
If present, the Chrome KSChannelID family of keys are rationalized by using
“universal” to identify the architecture (compared to, for example,
input_plists = [_read_plist(x) for x in input_paths]
output_plist = input_plists[0]
for index in range(1, len(input_plists)):
input_plist = input_plists[index]
for key in set(input_plist.keys()) | set(output_plist.keys()):
if input_plist.get(key, None) == output_plist.get(key, None):
if key in ('BuildMachineOSBuild', 'DTCompiler', 'DTPlatformBuild',
'DTPlatformName', 'DTPlatformVersion', 'DTSDKBuild',
'DTSDKName', 'DTXcode', 'DTXcodeBuild'):
if key in input_plist:
del input_plist[key]
if key in output_plist:
del output_plist[key]
elif key == 'KSChannelID' or key.startswith('KSChannelID-'):
# These keys are Chrome-specific, where it’s only present in the
# outer browser .app’s Info.plist.
# Ensure that the values match the expected format as a
# prerequisite to what follows.
key_tail = key[len('KSChannelID'):]
input_value = input_plist.get(key, '')
output_value = output_plist.get(key, '')
assert input_value.endswith(key_tail)
assert output_value.endswith(key_tail)
# Find the longest common trailing sequence of hyphen-separated
# elements, and use that as the trailing sequence of the new
# value.
input_parts = reversed(input_value.split('-'))
output_parts = output_value.split('-')
new_parts = []
for input_part, output_part in zip(input_parts, output_parts):
if input_part == output_part:
# Prepend “universal” to the entire value if it’s not already
# there.
if len(new_parts) == 0 or new_parts[-1] != 'universal':
output_plist[key] = '-'.join(reversed(new_parts))
assert output_plist[key] != ''
raise CantMergeException(input_paths[index], output_path)
_write_plist(output_plist, output_path)
def _universalize(input_paths, output_path, root):
"""Merges multiple trees into a “universal” tree.
This function provides the recursive internal implementation for
input_paths: The input directory trees to be merged.
output_path: The merged tree to produce.
root: True if operating at the root of the input and output trees.
input_stats = [_stat_or_none(x, root) for x in input_paths]
for index in range(len(input_paths) - 1, -1, -1):
if input_stats[index] is None:
del input_paths[index]
del input_stats[index]
input_types = [_file_type_for_stat(x) for x in input_stats]
type = _sole_list_element(
'varying types %r for input paths %r' % (input_types, input_paths))
if type == 'file':
identical = True
for index in range(1, len(input_paths)):
if not filecmp.cmp(input_paths[0], input_paths[index]):
identical = False
if (os.path.basename(output_path) == 'Info.plist' or
_merge_info_plists(input_paths, output_path)
command = ['lipo', '-create']
command.extend(['-output', output_path])
if identical:
shutil.copyfile(input_paths[0], output_path)
elif type == 'directory':
entries = set()
for input in input_paths:
for entry in entries:
input_entry_paths = [os.path.join(x, entry) for x in input_paths]
output_entry_path = os.path.join(output_path, entry)
_universalize(input_entry_paths, output_entry_path, False)
elif type == 'symbolic_link':
targets = [os.readlink(x) for x in input_paths]
target = _sole_list_element(
targets, 'varying symbolic link targets %r for input paths %r' %
(targets, input_paths))
os.symlink(target, output_path)
input_permissions = [stat.S_IMODE(x.st_mode) for x in input_stats]
permission = _sole_list_element(
input_permissions, 'varying permissions %r for input paths %r' %
(['0o%o' % x for x in input_permissions], input_paths))
os.lchmod(output_path, permission)
if type != 'file' or identical:
input_mtimes = [x.st_mtime for x in input_stats]
if len(set(input_mtimes)) == 1:
times = (time.time(), input_mtimes[0])
# follow_symlinks is only available since Python 3.3.
os.utime(output_path, times, follow_symlinks=False)
except TypeError:
# If it’s a symbolic link and this version of Python isn’t able
# to set its timestamp, just leave it alone.
if type != 'symbolic_link':
os.utime(output_path, times)
elif type == 'directory':
# Always touch directories, in case a directory is a bundle, as a
# cue to LaunchServices to invalidate anything it may have cached
# about the bundle as it was being built.
os.utime(output_path, None)
def universalize(input_paths, output_path):
"""Merges multiple trees into a “universal” tree.
input_paths: The input directory trees to be merged.
output_path: The merged tree to produce.
input_paths are expected to be parallel directory trees. Each directory
entry at a given subpath in the input_paths, if present, must be identical
to all others when present, with these exceptions:
- Mach-O files that are not identical are merged using lipo.
- Info.plist files that are not identical are merged by _merge_info_plists.
rmtree_on_error = not os.path.exists(output_path)
return _universalize(input_paths, output_path, True)
if rmtree_on_error and os.path.exists(output_path):
def main(args):
parser = argparse.ArgumentParser(
description='Merge multiple single-architecture directory trees into a '
'single universal tree.')
help='An input directory tree to be merged. At least two inputs must '
'be provided.')
parser.add_argument('output', help='The merged directory tree to produce.')
parsed = parser.parse_args(args)
if len(parsed.inputs) < 2:
raise Exception('too few inputs')
universalize(parsed.inputs, parsed.output)
if __name__ == '__main__':