846beb7f54
Previously, the bootclasspath_fragment's hidden_api.split_packages and
hidden_api.package_prefixes properties did not specify an exhaustive
set of packages that were provided by the fragment. They excluded
packages which were either not split or which could not be used as a
package prefix because it would match sub-packages provided by other
bootclasspath modules.
This change adds the hidden_api.single_packages list to specify those
additional packages and then uses that information to verify that any
bootclasspath_fragment that specifies at least one of split_packages,
single_packages or package_prefixes properties only contains classes
from a package that matches one of those properties. That will
prevent a module from accidentally including unexpected classes, such
as might happen when statically including a common utility library.
It also adds coverage specific versions of the properties as additional
packages are added to the art-bootclasspath-fragment when building
coverage builds.
Bug: 194063708
Test: atest signature_patterns_test
m out/soong/hiddenapi/hiddenapi-flags.csv
m EMMA_INSTRUMENT=true EMMA_INSTRUMENT_FRAMEWORK=true out/soong/hiddenapi/hiddenapi-flags.csv
# Breaks without corresponding change to add android.system to
# the art-bootclasspath-fragment.
/usr/bin/pylint --rcfile $ANDROID_BUILD_TOP/tools/repohooks/tools/pylintrc scripts/hiddenapi/signature_patterns*.py
pyformat -s 4 --force_quote_type single -i scripts/hiddenapi/signature_patterns*.py
Change-Id: Iddf6c59cd4dc8c36dde7943a9840ccef5794b320
281 lines
10 KiB
Python
Executable file
281 lines
10 KiB
Python
Executable file
#!/usr/bin/env python
|
|
#
|
|
# Copyright (C) 2021 The Android Open Source Project
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
"""Generate a set of signature patterns for a bootclasspath_fragment.
|
|
|
|
The patterns are generated from the modular flags produced by the
|
|
bootclasspath_fragment and are used to select a subset of the monolithic flags
|
|
against which the modular flags can be compared.
|
|
"""
|
|
|
|
import argparse
|
|
import csv
|
|
import sys
|
|
|
|
|
|
def dict_reader(csv_file):
|
|
return csv.DictReader(
|
|
csv_file, delimiter=',', quotechar='|', fieldnames=['signature'])
|
|
|
|
|
|
def dot_package_to_slash_package(pkg):
|
|
return pkg.replace('.', '/')
|
|
|
|
|
|
def dot_packages_to_slash_packages(pkgs):
|
|
return [dot_package_to_slash_package(p) for p in pkgs]
|
|
|
|
|
|
def slash_package_to_dot_package(pkg):
|
|
return pkg.replace('/', '.')
|
|
|
|
|
|
def slash_packages_to_dot_packages(pkgs):
|
|
return [slash_package_to_dot_package(p) for p in pkgs]
|
|
|
|
|
|
def is_split_package(split_packages, pkg):
|
|
return split_packages and (pkg in split_packages or '*' in split_packages)
|
|
|
|
|
|
def matched_by_package_prefix_pattern(package_prefixes, prefix):
|
|
for packagePrefix in package_prefixes:
|
|
if prefix == packagePrefix:
|
|
return packagePrefix
|
|
if (prefix.startswith(packagePrefix) and
|
|
prefix[len(packagePrefix)] == '/'):
|
|
return packagePrefix
|
|
return False
|
|
|
|
|
|
def validate_package_is_not_matched_by_package_prefix(package_type, pkg,
|
|
package_prefixes):
|
|
package_prefix = matched_by_package_prefix_pattern(package_prefixes, pkg)
|
|
if package_prefix:
|
|
# A package prefix matches the package.
|
|
package_for_output = slash_package_to_dot_package(pkg)
|
|
package_prefix_for_output = slash_package_to_dot_package(package_prefix)
|
|
return [
|
|
f'{package_type} {package_for_output} is matched by '
|
|
f'package prefix {package_prefix_for_output}'
|
|
]
|
|
return []
|
|
|
|
|
|
def validate_package_prefixes(split_packages, single_packages,
|
|
package_prefixes):
|
|
# If there are no package prefixes then there is no possible conflict
|
|
# between them and the split packages.
|
|
if len(package_prefixes) == 0:
|
|
return []
|
|
|
|
# Check to make sure that the split packages and package prefixes do not
|
|
# overlap.
|
|
errors = []
|
|
for split_package in split_packages:
|
|
if split_package == '*':
|
|
# A package prefix matches a split package.
|
|
package_prefixes_for_output = ', '.join(
|
|
slash_packages_to_dot_packages(package_prefixes))
|
|
errors.append(
|
|
"split package '*' conflicts with all package prefixes "
|
|
f'{package_prefixes_for_output}\n'
|
|
' add split_packages:[] to fix')
|
|
else:
|
|
errs = validate_package_is_not_matched_by_package_prefix(
|
|
'split package', split_package, package_prefixes)
|
|
errors.extend(errs)
|
|
|
|
# Check to make sure that the single packages and package prefixes do not
|
|
# overlap.
|
|
for single_package in single_packages:
|
|
errs = validate_package_is_not_matched_by_package_prefix(
|
|
'single package', single_package, package_prefixes)
|
|
errors.extend(errs)
|
|
return errors
|
|
|
|
|
|
def validate_split_packages(split_packages):
|
|
errors = []
|
|
if '*' in split_packages and len(split_packages) > 1:
|
|
errors.append('split packages are invalid as they contain both the'
|
|
' wildcard (*) and specific packages, use the wildcard or'
|
|
' specific packages, not a mixture')
|
|
return errors
|
|
|
|
|
|
def validate_single_packages(split_packages, single_packages):
|
|
overlaps = []
|
|
for single_package in single_packages:
|
|
if single_package in split_packages:
|
|
overlaps.append(single_package)
|
|
if overlaps:
|
|
indented = ''.join([f'\n {o}' for o in overlaps])
|
|
return [
|
|
f'single_packages and split_packages overlap, please ensure the '
|
|
f'following packages are only present in one:{indented}'
|
|
]
|
|
return []
|
|
|
|
|
|
def produce_patterns_from_file(file,
|
|
split_packages=None,
|
|
single_packages=None,
|
|
package_prefixes=None):
|
|
with open(file, 'r', encoding='utf8') as f:
|
|
return produce_patterns_from_stream(f, split_packages, single_packages,
|
|
package_prefixes)
|
|
|
|
|
|
def produce_patterns_from_stream(stream,
|
|
split_packages=None,
|
|
single_packages=None,
|
|
package_prefixes=None):
|
|
split_packages = set(split_packages or [])
|
|
single_packages = set(single_packages or [])
|
|
package_prefixes = list(package_prefixes or [])
|
|
# Read in all the signatures into a list and remove any unnecessary class
|
|
# and member names.
|
|
patterns = set()
|
|
unmatched_packages = set()
|
|
for row in dict_reader(stream):
|
|
signature = row['signature']
|
|
text = signature.removeprefix('L')
|
|
# Remove the class specific member signature
|
|
pieces = text.split(';->')
|
|
qualified_class_name = pieces[0]
|
|
pieces = qualified_class_name.rsplit('/', maxsplit=1)
|
|
pkg = pieces[0]
|
|
# If the package is split across multiple modules then it cannot be used
|
|
# to select the subset of the monolithic flags that this module
|
|
# produces. In that case we need to keep the name of the class but can
|
|
# discard any nested class names as an outer class cannot be split
|
|
# across modules.
|
|
#
|
|
# If the package is not split then every class in the package must be
|
|
# provided by this module so there is no need to list the classes
|
|
# explicitly so just use the package name instead.
|
|
if is_split_package(split_packages, pkg):
|
|
# Remove inner class names.
|
|
pieces = qualified_class_name.split('$', maxsplit=1)
|
|
pattern = pieces[0]
|
|
patterns.add(pattern)
|
|
elif pkg in single_packages:
|
|
# Add a * to ensure that the pattern matches the classes in that
|
|
# package.
|
|
pattern = pkg + '/*'
|
|
patterns.add(pattern)
|
|
else:
|
|
unmatched_packages.add(pkg)
|
|
|
|
# Remove any unmatched packages that would be matched by a package prefix
|
|
# pattern.
|
|
unmatched_packages = [
|
|
p for p in unmatched_packages
|
|
if not matched_by_package_prefix_pattern(package_prefixes, p)
|
|
]
|
|
errors = []
|
|
if unmatched_packages:
|
|
unmatched_packages.sort()
|
|
indented = ''.join([
|
|
f'\n {slash_package_to_dot_package(p)}'
|
|
for p in unmatched_packages
|
|
])
|
|
errors.append('The following packages were unexpected, please add them '
|
|
'to one of the hidden_api properties, split_packages, '
|
|
f'single_packages or package_prefixes:{indented}')
|
|
|
|
# Remove any patterns that would be matched by a package prefix pattern.
|
|
patterns = [
|
|
p for p in patterns
|
|
if not matched_by_package_prefix_pattern(package_prefixes, p)
|
|
]
|
|
# Add the package prefix patterns to the list. Add a ** to ensure that each
|
|
# package prefix pattern will match the classes in that package and all
|
|
# sub-packages.
|
|
patterns = patterns + [f'{p}/**' for p in package_prefixes]
|
|
# Sort the patterns.
|
|
patterns.sort()
|
|
return patterns, errors
|
|
|
|
|
|
def print_and_exit(errors):
|
|
for error in errors:
|
|
print(error)
|
|
sys.exit(1)
|
|
|
|
|
|
def main(args):
|
|
args_parser = argparse.ArgumentParser(
|
|
description='Generate a set of signature patterns '
|
|
'that select a subset of monolithic hidden API files.')
|
|
args_parser.add_argument(
|
|
'--flags',
|
|
help='The stub flags file which contains an entry for every dex member',
|
|
)
|
|
args_parser.add_argument(
|
|
'--split-package',
|
|
action='append',
|
|
help='A package that is split across multiple bootclasspath_fragment '
|
|
'modules')
|
|
args_parser.add_argument(
|
|
'--package-prefix',
|
|
action='append',
|
|
help='A package prefix unique to this set of flags')
|
|
args_parser.add_argument(
|
|
'--single-package',
|
|
action='append',
|
|
help='A single package unique to this set of flags')
|
|
args_parser.add_argument('--output', help='Generated signature prefixes')
|
|
args = args_parser.parse_args(args)
|
|
|
|
split_packages = set(
|
|
dot_packages_to_slash_packages(args.split_package or []))
|
|
errors = validate_split_packages(split_packages)
|
|
if errors:
|
|
print_and_exit(errors)
|
|
|
|
single_packages = list(
|
|
dot_packages_to_slash_packages(args.single_package or []))
|
|
|
|
errors = validate_single_packages(split_packages, single_packages)
|
|
if errors:
|
|
print_and_exit(errors)
|
|
|
|
package_prefixes = dot_packages_to_slash_packages(args.package_prefix or [])
|
|
|
|
errors = validate_package_prefixes(split_packages, single_packages,
|
|
package_prefixes)
|
|
if errors:
|
|
print_and_exit(errors)
|
|
|
|
patterns = []
|
|
# Read in all the patterns into a list.
|
|
patterns, errors = produce_patterns_from_file(args.flags, split_packages,
|
|
single_packages,
|
|
package_prefixes)
|
|
|
|
if errors:
|
|
print_and_exit(errors)
|
|
|
|
# Write out all the patterns.
|
|
with open(args.output, 'w', encoding='utf8') as outputFile:
|
|
for pattern in patterns:
|
|
outputFile.write(pattern)
|
|
outputFile.write('\n')
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main(sys.argv[1:])
|