b99d480e1d
Previously, the script would determine whether a package was split,
single or could be used as a prefix but did not explain why. This
change provides additional information to explain why they are split.
Bug: 202154151
Test: m analyze_bcpf && analyze_bcpf --bcpf art-bootclasspath-fragment
m analyze_bcpf && analyze_bcpf --bcpf art-bootclasspath-fragment --fix
atest --host analyze_bcpf_test
Change-Id: I3e2d5c0b54b5cc028013ce5ea979ebd9b9bf2c0d
1477 lines
59 KiB
Python
1477 lines
59 KiB
Python
#!/usr/bin/env -S python -u
|
|
#
|
|
# Copyright (C) 2022 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.
|
|
"""Analyze bootclasspath_fragment usage."""
|
|
import argparse
|
|
import dataclasses
|
|
import enum
|
|
import json
|
|
import logging
|
|
import os
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import tempfile
|
|
import textwrap
|
|
import typing
|
|
from enum import Enum
|
|
|
|
import sys
|
|
|
|
from signature_trie import signature_trie
|
|
|
|
_STUB_FLAGS_FILE = "out/soong/hiddenapi/hiddenapi-stub-flags.txt"
|
|
|
|
_FLAGS_FILE = "out/soong/hiddenapi/hiddenapi-flags.csv"
|
|
|
|
_INCONSISTENT_FLAGS = "ERROR: Hidden API flags are inconsistent:"
|
|
|
|
|
|
class BuildOperation:
|
|
|
|
def __init__(self, popen):
|
|
self.popen = popen
|
|
self.returncode = None
|
|
|
|
def lines(self):
|
|
"""Return an iterator over the lines output by the build operation.
|
|
|
|
The lines have had any trailing white space, including the newline
|
|
stripped.
|
|
"""
|
|
return newline_stripping_iter(self.popen.stdout.readline)
|
|
|
|
def wait(self, *args, **kwargs):
|
|
self.popen.wait(*args, **kwargs)
|
|
self.returncode = self.popen.returncode
|
|
|
|
|
|
@dataclasses.dataclass()
|
|
class FlagDiffs:
|
|
"""Encapsulates differences in flags reported by the build"""
|
|
|
|
# Map from member signature to the (module flags, monolithic flags)
|
|
diffs: typing.Dict[str, typing.Tuple[str, str]]
|
|
|
|
|
|
@dataclasses.dataclass()
|
|
class ModuleInfo:
|
|
"""Provides access to the generated module-info.json file.
|
|
|
|
This is used to find the location of the file within which specific modules
|
|
are defined.
|
|
"""
|
|
|
|
modules: typing.Dict[str, typing.Dict[str, typing.Any]]
|
|
|
|
@staticmethod
|
|
def load(filename):
|
|
with open(filename, "r", encoding="utf8") as f:
|
|
j = json.load(f)
|
|
return ModuleInfo(j)
|
|
|
|
def _module(self, module_name):
|
|
"""Find module by name in module-info.json file"""
|
|
if module_name in self.modules:
|
|
return self.modules[module_name]
|
|
|
|
raise Exception(f"Module {module_name} could not be found")
|
|
|
|
def module_path(self, module_name):
|
|
module = self._module(module_name)
|
|
# The "path" is actually a list of paths, one for each class of module
|
|
# but as the modules are all created from bp files if a module does
|
|
# create multiple classes of make modules they should all have the same
|
|
# path.
|
|
paths = module["path"]
|
|
unique_paths = set(paths)
|
|
if len(unique_paths) != 1:
|
|
raise Exception(f"Expected module '{module_name}' to have a "
|
|
f"single unique path but found {unique_paths}")
|
|
return paths[0]
|
|
|
|
|
|
def extract_indent(line):
|
|
return re.match(r"([ \t]*)", line).group(1)
|
|
|
|
|
|
_SPECIAL_PLACEHOLDER: str = "SPECIAL_PLACEHOLDER"
|
|
|
|
|
|
@dataclasses.dataclass
|
|
class BpModifyRunner:
|
|
|
|
bpmodify_path: str
|
|
|
|
def add_values_to_property(self, property_name, values, module_name,
|
|
bp_file):
|
|
cmd = [
|
|
self.bpmodify_path, "-a", values, "-property", property_name, "-m",
|
|
module_name, "-w", bp_file, bp_file
|
|
]
|
|
|
|
logging.debug(" ".join(cmd))
|
|
subprocess.run(
|
|
cmd,
|
|
stderr=subprocess.STDOUT,
|
|
stdout=log_stream_for_subprocess(),
|
|
check=True)
|
|
|
|
|
|
@dataclasses.dataclass
|
|
class FileChange:
|
|
path: str
|
|
|
|
description: str
|
|
|
|
def __lt__(self, other):
|
|
return self.path < other.path
|
|
|
|
|
|
class PropertyChangeAction(Enum):
|
|
"""Allowable actions that are supported by HiddenApiPropertyChange."""
|
|
|
|
# New values are appended to any existing values.
|
|
APPEND = 1
|
|
|
|
# New values replace any existing values.
|
|
REPLACE = 2
|
|
|
|
|
|
@dataclasses.dataclass
|
|
class HiddenApiPropertyChange:
|
|
|
|
property_name: str
|
|
|
|
values: typing.List[str]
|
|
|
|
property_comment: str = ""
|
|
|
|
# The action that indicates how this change is applied.
|
|
action: PropertyChangeAction = PropertyChangeAction.APPEND
|
|
|
|
def snippet(self, indent):
|
|
snippet = "\n"
|
|
snippet += format_comment_as_text(self.property_comment, indent)
|
|
snippet += f"{indent}{self.property_name}: ["
|
|
if self.values:
|
|
snippet += "\n"
|
|
for value in self.values:
|
|
snippet += f'{indent} "{value}",\n'
|
|
snippet += f"{indent}"
|
|
snippet += "],\n"
|
|
return snippet
|
|
|
|
def fix_bp_file(self, bcpf_bp_file, bcpf, bpmodify_runner: BpModifyRunner):
|
|
# Add an additional placeholder value to identify the modification that
|
|
# bpmodify makes.
|
|
bpmodify_values = [_SPECIAL_PLACEHOLDER]
|
|
|
|
if self.action == PropertyChangeAction.APPEND:
|
|
# If adding the values to the existing values then pass the new
|
|
# values to bpmodify.
|
|
bpmodify_values.extend(self.values)
|
|
elif self.action == PropertyChangeAction.REPLACE:
|
|
# If replacing the existing values then it is not possible to use
|
|
# bpmodify for that directly. It could be used twice to remove the
|
|
# existing property and then add a new one but that does not remove
|
|
# any related comments and loses the position of the existing
|
|
# property as the new property is always added to the end of the
|
|
# containing block.
|
|
#
|
|
# So, instead of passing the new values to bpmodify this this just
|
|
# adds an extra placeholder to force bpmodify to format the list
|
|
# across multiple lines to ensure a consistent structure for the
|
|
# code that removes all the existing values and adds the new ones.
|
|
#
|
|
# This placeholder has to be different to the other placeholder as
|
|
# bpmodify dedups values.
|
|
bpmodify_values.append(_SPECIAL_PLACEHOLDER + "_REPLACE")
|
|
else:
|
|
raise ValueError(f"unknown action {self.action}")
|
|
|
|
packages = ",".join(bpmodify_values)
|
|
bpmodify_runner.add_values_to_property(
|
|
f"hidden_api.{self.property_name}", packages, bcpf, bcpf_bp_file)
|
|
|
|
with open(bcpf_bp_file, "r", encoding="utf8") as tio:
|
|
lines = tio.readlines()
|
|
lines = [line.rstrip("\n") for line in lines]
|
|
|
|
if self.fixup_bpmodify_changes(bcpf_bp_file, lines):
|
|
with open(bcpf_bp_file, "w", encoding="utf8") as tio:
|
|
for line in lines:
|
|
print(line, file=tio)
|
|
|
|
def fixup_bpmodify_changes(self, bcpf_bp_file, lines):
|
|
"""Fixup the output of bpmodify.
|
|
|
|
The bpmodify tool does not support all the capabilities that this needs
|
|
so it is used to do what it can, including marking the place in the
|
|
Android.bp file where it makes its changes and then this gets passed a
|
|
list of lines from that file which it then modifies to complete the
|
|
change.
|
|
|
|
This analyzes the list of lines to find the indices of the significant
|
|
lines and then applies some changes. As those changes can insert and
|
|
delete lines (changing the indices of following lines) the changes are
|
|
generally done in reverse order starting from the end and working
|
|
towards the beginning. That ensures that the changes do not invalidate
|
|
the indices of following lines.
|
|
"""
|
|
|
|
# Find the line containing the placeholder that has been inserted.
|
|
place_holder_index = -1
|
|
for i, line in enumerate(lines):
|
|
if _SPECIAL_PLACEHOLDER in line:
|
|
place_holder_index = i
|
|
break
|
|
if place_holder_index == -1:
|
|
logging.debug("Could not find %s in %s", _SPECIAL_PLACEHOLDER,
|
|
bcpf_bp_file)
|
|
return False
|
|
|
|
# Remove the place holder. Do this before inserting the comment as that
|
|
# would change the location of the place holder in the list.
|
|
place_holder_line = lines[place_holder_index]
|
|
if place_holder_line.endswith("],"):
|
|
place_holder_line = place_holder_line.replace(
|
|
f'"{_SPECIAL_PLACEHOLDER}"', "")
|
|
lines[place_holder_index] = place_holder_line
|
|
else:
|
|
del lines[place_holder_index]
|
|
|
|
# Scan forward to the end of the property block to remove a blank line
|
|
# that bpmodify inserts.
|
|
end_property_array_index = -1
|
|
for i in range(place_holder_index, len(lines)):
|
|
line = lines[i]
|
|
if line.endswith("],"):
|
|
end_property_array_index = i
|
|
break
|
|
if end_property_array_index == -1:
|
|
logging.debug("Could not find end of property array in %s",
|
|
bcpf_bp_file)
|
|
return False
|
|
|
|
# If bdmodify inserted a blank line afterwards then remove it.
|
|
if (not lines[end_property_array_index + 1] and
|
|
lines[end_property_array_index + 2].endswith("},")):
|
|
del lines[end_property_array_index + 1]
|
|
|
|
# Scan back to find the preceding property line.
|
|
property_line_index = -1
|
|
for i in range(place_holder_index, 0, -1):
|
|
line = lines[i]
|
|
if line.lstrip().startswith(f"{self.property_name}: ["):
|
|
property_line_index = i
|
|
break
|
|
if property_line_index == -1:
|
|
logging.debug("Could not find property line in %s", bcpf_bp_file)
|
|
return False
|
|
|
|
# If this change is replacing the existing values then they need to be
|
|
# removed and replaced with the new values. That will change the lines
|
|
# after the property but it is necessary to do here as the following
|
|
# code operates on earlier lines.
|
|
if self.action == PropertyChangeAction.REPLACE:
|
|
# This removes the existing values and replaces them with the new
|
|
# values.
|
|
indent = extract_indent(lines[property_line_index + 1])
|
|
insert = [f'{indent}"{x}",' for x in self.values]
|
|
lines[property_line_index + 1:end_property_array_index] = insert
|
|
if not self.values:
|
|
# If the property has no values then merge the ], onto the
|
|
# same line as the property name.
|
|
del lines[property_line_index + 1]
|
|
lines[property_line_index] = lines[property_line_index] + "],"
|
|
|
|
# Only insert a comment if the property does not already have a comment.
|
|
line_preceding_property = lines[(property_line_index - 1)]
|
|
if (self.property_comment and
|
|
not re.match("([ \t]+)// ", line_preceding_property)):
|
|
# Extract the indent from the property line and use it to format the
|
|
# comment.
|
|
indent = extract_indent(lines[property_line_index])
|
|
comment_lines = format_comment_as_lines(self.property_comment,
|
|
indent)
|
|
|
|
# If the line before the comment is not blank then insert an extra
|
|
# blank line at the beginning of the comment.
|
|
if line_preceding_property:
|
|
comment_lines.insert(0, "")
|
|
|
|
# Insert the comment before the property.
|
|
lines[property_line_index:property_line_index] = comment_lines
|
|
return True
|
|
|
|
|
|
@dataclasses.dataclass()
|
|
class PackagePropertyReason:
|
|
"""Provides the reasons why a package was added to a specific property.
|
|
|
|
A split package is one that contains classes from the bootclasspath_fragment
|
|
and other bootclasspath modules. So, for a split package this contains the
|
|
corresponding lists of classes.
|
|
|
|
A single package is one that contains classes sub-packages from the
|
|
For a split package this contains a list of classes in that package that are
|
|
provided by the bootclasspath_fragment and a list of classes
|
|
"""
|
|
|
|
# The list of classes/sub-packages that is provided by the
|
|
# bootclasspath_fragment.
|
|
bcpf: typing.List[str]
|
|
|
|
# The list of classes/sub-packages that is provided by other modules on the
|
|
# bootclasspath.
|
|
other: typing.List[str]
|
|
|
|
|
|
@dataclasses.dataclass()
|
|
class Result:
|
|
"""Encapsulates the result of the analysis."""
|
|
|
|
# The diffs in the flags.
|
|
diffs: typing.Optional[FlagDiffs] = None
|
|
|
|
# A map from package name to the reason why it belongs in the
|
|
# split_packages property.
|
|
split_packages: typing.Dict[str, PackagePropertyReason] = dataclasses.field(
|
|
default_factory=dict)
|
|
|
|
# A map from package name to the reason why it belongs in the
|
|
# single_packages property.
|
|
single_packages: typing.Dict[str,
|
|
PackagePropertyReason] = dataclasses.field(
|
|
default_factory=dict)
|
|
|
|
# The list of packages to add to the package_prefixes property.
|
|
package_prefixes: typing.List[str] = dataclasses.field(default_factory=list)
|
|
|
|
# The bootclasspath_fragment hidden API properties changes.
|
|
property_changes: typing.List[HiddenApiPropertyChange] = dataclasses.field(
|
|
default_factory=list)
|
|
|
|
# The list of file changes.
|
|
file_changes: typing.List[FileChange] = dataclasses.field(
|
|
default_factory=list)
|
|
|
|
|
|
class ClassProvider(enum.Enum):
|
|
"""The source of a class found during the hidden API processing"""
|
|
BCPF = "bcpf"
|
|
OTHER = "other"
|
|
|
|
|
|
# A fake member to use when using the signature trie to compute the package
|
|
# properties from hidden API flags. This is needed because while that
|
|
# computation only cares about classes the trie expects a class to be an
|
|
# interior node but without a member it makes the class a leaf node. That causes
|
|
# problems when analyzing inner classes as the outer class is a leaf node for
|
|
# its own entry but is used as an interior node for inner classes.
|
|
_FAKE_MEMBER = ";->fake()V"
|
|
|
|
|
|
@dataclasses.dataclass()
|
|
class BcpfAnalyzer:
|
|
# Path to this tool.
|
|
tool_path: str
|
|
|
|
# Directory pointed to by ANDROID_BUILD_OUT
|
|
top_dir: str
|
|
|
|
# Directory pointed to by OUT_DIR of {top_dir}/out if that is not set.
|
|
out_dir: str
|
|
|
|
# Directory pointed to by ANDROID_PRODUCT_OUT.
|
|
product_out_dir: str
|
|
|
|
# The name of the bootclasspath_fragment module.
|
|
bcpf: str
|
|
|
|
# The name of the apex module containing {bcpf}, only used for
|
|
# informational purposes.
|
|
apex: str
|
|
|
|
# The name of the sdk module containing {bcpf}, only used for
|
|
# informational purposes.
|
|
sdk: str
|
|
|
|
# If true then this will attempt to automatically fix any issues that are
|
|
# found.
|
|
fix: bool = False
|
|
|
|
# All the signatures, loaded from all-flags.csv, initialized by
|
|
# load_all_flags().
|
|
_signatures: typing.Set[str] = dataclasses.field(default_factory=set)
|
|
|
|
# All the classes, loaded from all-flags.csv, initialized by
|
|
# load_all_flags().
|
|
_classes: typing.Set[str] = dataclasses.field(default_factory=set)
|
|
|
|
# Information loaded from module-info.json, initialized by
|
|
# load_module_info().
|
|
module_info: ModuleInfo = None
|
|
|
|
@staticmethod
|
|
def reformat_report_test(text):
|
|
return re.sub(r"(.)\n([^\s])", r"\1 \2", text)
|
|
|
|
def report(self, text="", **kwargs):
|
|
# Concatenate lines that are not separated by a blank line together to
|
|
# eliminate formatting applied to the supplied text to adhere to python
|
|
# line length limitations.
|
|
text = self.reformat_report_test(text)
|
|
logging.info("%s", text, **kwargs)
|
|
|
|
def report_dedent(self, text, **kwargs):
|
|
text = textwrap.dedent(text)
|
|
self.report(text, **kwargs)
|
|
|
|
def run_command(self, cmd, *args, **kwargs):
|
|
cmd_line = " ".join(cmd)
|
|
logging.debug("Running %s", cmd_line)
|
|
subprocess.run(
|
|
cmd,
|
|
*args,
|
|
check=True,
|
|
cwd=self.top_dir,
|
|
stderr=subprocess.STDOUT,
|
|
stdout=log_stream_for_subprocess(),
|
|
text=True,
|
|
**kwargs)
|
|
|
|
@property
|
|
def signatures(self):
|
|
if not self._signatures:
|
|
raise Exception("signatures has not been initialized")
|
|
return self._signatures
|
|
|
|
@property
|
|
def classes(self):
|
|
if not self._classes:
|
|
raise Exception("classes has not been initialized")
|
|
return self._classes
|
|
|
|
def load_all_flags(self):
|
|
all_flags = self.find_bootclasspath_fragment_output_file(
|
|
"all-flags.csv")
|
|
|
|
# Extract the set of signatures and a separate set of classes produced
|
|
# by the bootclasspath_fragment.
|
|
with open(all_flags, "r", encoding="utf8") as f:
|
|
for line in newline_stripping_iter(f.readline):
|
|
signature = self.line_to_signature(line)
|
|
self._signatures.add(signature)
|
|
class_name = self.signature_to_class(signature)
|
|
self._classes.add(class_name)
|
|
|
|
def load_module_info(self):
|
|
module_info_file = os.path.join(self.product_out_dir,
|
|
"module-info.json")
|
|
self.report(f"\nMaking sure that {module_info_file} is up to date.\n")
|
|
output = self.build_file_read_output(module_info_file)
|
|
lines = output.lines()
|
|
for line in lines:
|
|
logging.debug("%s", line)
|
|
output.wait(timeout=10)
|
|
if output.returncode:
|
|
raise Exception(f"Error building {module_info_file}")
|
|
abs_module_info_file = os.path.join(self.top_dir, module_info_file)
|
|
self.module_info = ModuleInfo.load(abs_module_info_file)
|
|
|
|
@staticmethod
|
|
def line_to_signature(line):
|
|
return line.split(",")[0]
|
|
|
|
@staticmethod
|
|
def signature_to_class(signature):
|
|
return signature.split(";->")[0]
|
|
|
|
@staticmethod
|
|
def to_parent_package(pkg_or_class):
|
|
return pkg_or_class.rsplit("/", 1)[0]
|
|
|
|
def module_path(self, module_name):
|
|
return self.module_info.module_path(module_name)
|
|
|
|
def module_out_dir(self, module_name):
|
|
module_path = self.module_path(module_name)
|
|
return os.path.join(self.out_dir, "soong/.intermediates", module_path,
|
|
module_name)
|
|
|
|
def find_bootclasspath_fragment_output_file(self, basename, required=True):
|
|
# Find the output file of the bootclasspath_fragment with the specified
|
|
# base name.
|
|
found_file = ""
|
|
bcpf_out_dir = self.module_out_dir(self.bcpf)
|
|
for (dirpath, _, filenames) in os.walk(bcpf_out_dir):
|
|
for f in filenames:
|
|
if f == basename:
|
|
found_file = os.path.join(dirpath, f)
|
|
break
|
|
if not found_file and required:
|
|
raise Exception(f"Could not find {basename} in {bcpf_out_dir}")
|
|
return found_file
|
|
|
|
def analyze(self):
|
|
"""Analyze a bootclasspath_fragment module.
|
|
|
|
Provides help in resolving any existing issues and provides
|
|
optimizations that can be applied.
|
|
"""
|
|
self.report(f"Analyzing bootclasspath_fragment module {self.bcpf}")
|
|
self.report_dedent(f"""
|
|
Run this tool to help initialize a bootclasspath_fragment module.
|
|
Before you start make sure that:
|
|
|
|
1. The current checkout is up to date.
|
|
|
|
2. The environment has been initialized using lunch, e.g.
|
|
lunch aosp_arm64-userdebug
|
|
|
|
3. You have added a bootclasspath_fragment module to the appropriate
|
|
Android.bp file. Something like this:
|
|
|
|
bootclasspath_fragment {{
|
|
name: "{self.bcpf}",
|
|
contents: [
|
|
"...",
|
|
],
|
|
|
|
// The bootclasspath_fragments that provide APIs on which this
|
|
// depends.
|
|
fragments: [
|
|
{{
|
|
apex: "com.android.art",
|
|
module: "art-bootclasspath-fragment",
|
|
}},
|
|
],
|
|
}}
|
|
|
|
4. You have added it to the platform_bootclasspath module in
|
|
frameworks/base/boot/Android.bp. Something like this:
|
|
|
|
platform_bootclasspath {{
|
|
name: "platform-bootclasspath",
|
|
fragments: [
|
|
...
|
|
{{
|
|
apex: "{self.apex}",
|
|
module: "{self.bcpf}",
|
|
}},
|
|
],
|
|
}}
|
|
|
|
5. You have added an sdk module. Something like this:
|
|
|
|
sdk {{
|
|
name: "{self.sdk}",
|
|
bootclasspath_fragments: ["{self.bcpf}"],
|
|
}}
|
|
""")
|
|
|
|
# Make sure that the module-info.json file is up to date.
|
|
self.load_module_info()
|
|
|
|
self.report_dedent("""
|
|
Cleaning potentially stale files.
|
|
""")
|
|
# Remove the out/soong/hiddenapi files.
|
|
shutil.rmtree(f"{self.out_dir}/soong/hiddenapi", ignore_errors=True)
|
|
|
|
# Remove any bootclasspath_fragment output files.
|
|
shutil.rmtree(self.module_out_dir(self.bcpf), ignore_errors=True)
|
|
|
|
self.build_monolithic_stubs_flags()
|
|
|
|
result = Result()
|
|
|
|
self.build_monolithic_flags(result)
|
|
self.analyze_hiddenapi_package_properties(result)
|
|
self.explain_how_to_check_signature_patterns()
|
|
|
|
# If there were any changes that need to be made to the Android.bp
|
|
# file then either apply or report them.
|
|
if result.property_changes:
|
|
bcpf_dir = self.module_info.module_path(self.bcpf)
|
|
bcpf_bp_file = os.path.join(self.top_dir, bcpf_dir, "Android.bp")
|
|
if self.fix:
|
|
tool_dir = os.path.dirname(self.tool_path)
|
|
bpmodify_path = os.path.join(tool_dir, "bpmodify")
|
|
bpmodify_runner = BpModifyRunner(bpmodify_path)
|
|
for property_change in result.property_changes:
|
|
property_change.fix_bp_file(bcpf_bp_file, self.bcpf,
|
|
bpmodify_runner)
|
|
|
|
result.file_changes.append(
|
|
self.new_file_change(
|
|
bcpf_bp_file,
|
|
f"Updated hidden_api properties of '{self.bcpf}'"))
|
|
|
|
else:
|
|
hiddenapi_snippet = ""
|
|
for property_change in result.property_changes:
|
|
hiddenapi_snippet += property_change.snippet(" ")
|
|
|
|
# Remove leading and trailing blank lines.
|
|
hiddenapi_snippet = hiddenapi_snippet.strip("\n")
|
|
|
|
result.file_changes.append(
|
|
self.new_file_change(
|
|
bcpf_bp_file, f"""
|
|
Add the following snippet into the {self.bcpf} bootclasspath_fragment module
|
|
in the {bcpf_dir}/Android.bp file. If the hidden_api block already exists then
|
|
merge these properties into it.
|
|
|
|
hidden_api: {{
|
|
{hiddenapi_snippet}
|
|
}},
|
|
"""))
|
|
|
|
if result.file_changes:
|
|
if self.fix:
|
|
file_change_message = textwrap.dedent("""
|
|
The following files were modified by this script:
|
|
""")
|
|
else:
|
|
file_change_message = textwrap.dedent("""
|
|
The following modifications need to be made:
|
|
""")
|
|
|
|
self.report(file_change_message)
|
|
result.file_changes.sort()
|
|
for file_change in result.file_changes:
|
|
self.report(f" {file_change.path}")
|
|
self.report(f" {file_change.description}")
|
|
self.report()
|
|
|
|
if not self.fix:
|
|
self.report_dedent("""
|
|
Run the command again with the --fix option to automatically
|
|
make the above changes.
|
|
""".lstrip("\n"))
|
|
|
|
def new_file_change(self, file, description):
|
|
return FileChange(
|
|
path=os.path.relpath(file, self.top_dir), description=description)
|
|
|
|
def check_inconsistent_flag_lines(self, significant, module_line,
|
|
monolithic_line, separator_line):
|
|
if not (module_line.startswith("< ") and
|
|
monolithic_line.startswith("> ") and not separator_line):
|
|
# Something went wrong.
|
|
self.report("Invalid build output detected:")
|
|
self.report(f" module_line: '{module_line}'")
|
|
self.report(f" monolithic_line: '{monolithic_line}'")
|
|
self.report(f" separator_line: '{separator_line}'")
|
|
sys.exit(1)
|
|
|
|
if significant:
|
|
logging.debug("%s", module_line)
|
|
logging.debug("%s", monolithic_line)
|
|
logging.debug("%s", separator_line)
|
|
|
|
def scan_inconsistent_flags_report(self, lines):
|
|
"""Scans a hidden API flags report
|
|
|
|
The hidden API inconsistent flags report which looks something like
|
|
this.
|
|
|
|
< out/soong/.intermediates/.../filtered-stub-flags.csv
|
|
> out/soong/hiddenapi/hiddenapi-stub-flags.txt
|
|
|
|
< Landroid/compat/Compatibility;->clearOverrides()V
|
|
> Landroid/compat/Compatibility;->clearOverrides()V,core-platform-api
|
|
|
|
"""
|
|
|
|
# The basic format of an entry in the inconsistent flags report is:
|
|
# <module specific flag>
|
|
# <monolithic flag>
|
|
# <separator>
|
|
#
|
|
# Wrap the lines iterator in an iterator which returns a tuple
|
|
# consisting of the three separate lines.
|
|
triples = zip(lines, lines, lines)
|
|
|
|
module_line, monolithic_line, separator_line = next(triples)
|
|
significant = False
|
|
bcpf_dir = self.module_info.module_path(self.bcpf)
|
|
if os.path.join(bcpf_dir, self.bcpf) in module_line:
|
|
# These errors are related to the bcpf being analyzed so
|
|
# keep them.
|
|
significant = True
|
|
else:
|
|
self.report(f"Filtering out errors related to {module_line}")
|
|
|
|
self.check_inconsistent_flag_lines(significant, module_line,
|
|
monolithic_line, separator_line)
|
|
|
|
diffs = {}
|
|
for module_line, monolithic_line, separator_line in triples:
|
|
self.check_inconsistent_flag_lines(significant, module_line,
|
|
monolithic_line, "")
|
|
|
|
module_parts = module_line.removeprefix("< ").split(",")
|
|
module_signature = module_parts[0]
|
|
module_flags = module_parts[1:]
|
|
|
|
monolithic_parts = monolithic_line.removeprefix("> ").split(",")
|
|
monolithic_signature = monolithic_parts[0]
|
|
monolithic_flags = monolithic_parts[1:]
|
|
|
|
if module_signature != monolithic_signature:
|
|
# Something went wrong.
|
|
self.report("Inconsistent signatures detected:")
|
|
self.report(f" module_signature: '{module_signature}'")
|
|
self.report(f" monolithic_signature: '{monolithic_signature}'")
|
|
sys.exit(1)
|
|
|
|
diffs[module_signature] = (module_flags, monolithic_flags)
|
|
|
|
if separator_line:
|
|
# If the separator line is not blank then it is the end of the
|
|
# current report, and possibly the start of another.
|
|
return separator_line, diffs
|
|
|
|
return "", diffs
|
|
|
|
def build_file_read_output(self, filename):
|
|
# Make sure the filename is relative to top if possible as the build
|
|
# may be using relative paths as the target.
|
|
rel_filename = filename.removeprefix(self.top_dir)
|
|
cmd = ["build/soong/soong_ui.bash", "--make-mode", rel_filename]
|
|
cmd_line = " ".join(cmd)
|
|
logging.debug("%s", cmd_line)
|
|
# pylint: disable=consider-using-with
|
|
output = subprocess.Popen(
|
|
cmd,
|
|
cwd=self.top_dir,
|
|
stderr=subprocess.STDOUT,
|
|
stdout=subprocess.PIPE,
|
|
text=True,
|
|
)
|
|
return BuildOperation(popen=output)
|
|
|
|
def build_hiddenapi_flags(self, filename):
|
|
output = self.build_file_read_output(filename)
|
|
|
|
lines = output.lines()
|
|
diffs = None
|
|
for line in lines:
|
|
logging.debug("%s", line)
|
|
while line == _INCONSISTENT_FLAGS:
|
|
line, diffs = self.scan_inconsistent_flags_report(lines)
|
|
|
|
output.wait(timeout=10)
|
|
if output.returncode != 0:
|
|
logging.debug("Command failed with %s", output.returncode)
|
|
else:
|
|
logging.debug("Command succeeded")
|
|
|
|
return diffs
|
|
|
|
def build_monolithic_stubs_flags(self):
|
|
self.report_dedent(f"""
|
|
Attempting to build {_STUB_FLAGS_FILE} to verify that the
|
|
bootclasspath_fragment has the correct API stubs available...
|
|
""")
|
|
|
|
# Build the hiddenapi-stubs-flags.txt file.
|
|
diffs = self.build_hiddenapi_flags(_STUB_FLAGS_FILE)
|
|
if diffs:
|
|
self.report_dedent(f"""
|
|
There is a discrepancy between the stub API derived flags
|
|
created by the bootclasspath_fragment and the
|
|
platform_bootclasspath. See preceding error messages to see
|
|
which flags are inconsistent. The inconsistencies can occur for
|
|
a couple of reasons:
|
|
|
|
If you are building against prebuilts of the Android SDK, e.g.
|
|
by using TARGET_BUILD_APPS then the prebuilt versions of the
|
|
APIs this bootclasspath_fragment depends upon are out of date
|
|
and need updating. See go/update-prebuilts for help.
|
|
|
|
Otherwise, this is happening because there are some stub APIs
|
|
that are either provided by or used by the contents of the
|
|
bootclasspath_fragment but which are not available to it. There
|
|
are 4 ways to handle this:
|
|
|
|
1. A java_sdk_library in the contents property will
|
|
automatically make its stub APIs available to the
|
|
bootclasspath_fragment so nothing needs to be done.
|
|
|
|
2. If the API provided by the bootclasspath_fragment is created
|
|
by an api_only java_sdk_library (or a java_library that compiles
|
|
files generated by a separate droidstubs module then it cannot
|
|
be added to the contents and instead must be added to the
|
|
api.stubs property, e.g.
|
|
|
|
bootclasspath_fragment {{
|
|
name: "{self.bcpf}",
|
|
...
|
|
api: {{
|
|
stubs: ["$MODULE-api-only"],"
|
|
}},
|
|
}}
|
|
|
|
3. If the contents use APIs provided by another
|
|
bootclasspath_fragment then it needs to be added to the
|
|
fragments property, e.g.
|
|
|
|
bootclasspath_fragment {{
|
|
name: "{self.bcpf}",
|
|
...
|
|
// The bootclasspath_fragments that provide APIs on which this depends.
|
|
fragments: [
|
|
...
|
|
{{
|
|
apex: "com.android.other",
|
|
module: "com.android.other-bootclasspath-fragment",
|
|
}},
|
|
],
|
|
}}
|
|
|
|
4. If the contents use APIs from a module that is not part of
|
|
another bootclasspath_fragment then it must be added to the
|
|
additional_stubs property, e.g.
|
|
|
|
bootclasspath_fragment {{
|
|
name: "{self.bcpf}",
|
|
...
|
|
additional_stubs: ["android-non-updatable"],
|
|
}}
|
|
|
|
Like the api.stubs property these are typically
|
|
java_sdk_library modules but can be java_library too.
|
|
|
|
Note: The "android-non-updatable" is treated as if it was a
|
|
java_sdk_library which it is not at the moment but will be in
|
|
future.
|
|
""")
|
|
|
|
return diffs
|
|
|
|
def build_monolithic_flags(self, result):
|
|
self.report_dedent(f"""
|
|
Attempting to build {_FLAGS_FILE} to verify that the
|
|
bootclasspath_fragment has the correct hidden API flags...
|
|
""")
|
|
|
|
# Build the hiddenapi-flags.csv file and extract any differences in
|
|
# the flags between this bootclasspath_fragment and the monolithic
|
|
# files.
|
|
result.diffs = self.build_hiddenapi_flags(_FLAGS_FILE)
|
|
|
|
# Load information from the bootclasspath_fragment's all-flags.csv file.
|
|
self.load_all_flags()
|
|
|
|
if result.diffs:
|
|
self.report_dedent(f"""
|
|
There is a discrepancy between the hidden API flags created by
|
|
the bootclasspath_fragment and the platform_bootclasspath. See
|
|
preceding error messages to see which flags are inconsistent.
|
|
The inconsistencies can occur for a couple of reasons:
|
|
|
|
If you are building against prebuilts of this
|
|
bootclasspath_fragment then the prebuilt version of the sdk
|
|
snapshot (specifically the hidden API flag files) are
|
|
inconsistent with the prebuilt version of the apex {self.apex}.
|
|
Please ensure that they are both updated from the same build.
|
|
|
|
1. There are custom hidden API flags specified in the one of the
|
|
files in frameworks/base/boot/hiddenapi which apply to the
|
|
bootclasspath_fragment but which are not supplied to the
|
|
bootclasspath_fragment module.
|
|
|
|
2. The bootclasspath_fragment specifies invalid
|
|
"split_packages", "single_packages" and/of "package_prefixes"
|
|
properties that match packages and classes that it does not
|
|
provide.
|
|
""")
|
|
|
|
# Check to see if there are any hiddenapi related properties that
|
|
# need to be added to the
|
|
self.report_dedent("""
|
|
Checking custom hidden API flags....
|
|
""")
|
|
self.check_frameworks_base_boot_hidden_api_files(result)
|
|
|
|
def report_hidden_api_flag_file_changes(self, result, property_name,
|
|
flags_file, rel_bcpf_flags_file,
|
|
bcpf_flags_file):
|
|
matched_signatures = set()
|
|
# Open the flags file to read the flags from.
|
|
with open(flags_file, "r", encoding="utf8") as f:
|
|
for signature in newline_stripping_iter(f.readline):
|
|
if signature in self.signatures:
|
|
# The signature is provided by the bootclasspath_fragment so
|
|
# it will need to be moved to the bootclasspath_fragment
|
|
# specific file.
|
|
matched_signatures.add(signature)
|
|
|
|
# If the bootclasspath_fragment specific flags file is not empty
|
|
# then it contains flags. That could either be new flags just moved
|
|
# from frameworks/base or previous contents of the file. In either
|
|
# case the file must not be removed.
|
|
if matched_signatures:
|
|
insert = textwrap.indent("\n".join(matched_signatures),
|
|
" ")
|
|
result.file_changes.append(
|
|
self.new_file_change(
|
|
flags_file, f"""Remove the following entries:
|
|
{insert}
|
|
"""))
|
|
|
|
result.file_changes.append(
|
|
self.new_file_change(
|
|
bcpf_flags_file, f"""Add the following entries:
|
|
{insert}
|
|
"""))
|
|
|
|
result.property_changes.append(
|
|
HiddenApiPropertyChange(
|
|
property_name=property_name,
|
|
values=[rel_bcpf_flags_file],
|
|
))
|
|
|
|
def fix_hidden_api_flag_files(self, result, property_name, flags_file,
|
|
rel_bcpf_flags_file, bcpf_flags_file):
|
|
# Read the file in frameworks/base/boot/hiddenapi/<file> copy any
|
|
# flags that relate to the bootclasspath_fragment into a local
|
|
# file in the hiddenapi subdirectory.
|
|
tmp_flags_file = flags_file + ".tmp"
|
|
|
|
# Make sure the directory containing the bootclasspath_fragment specific
|
|
# hidden api flags exists.
|
|
os.makedirs(os.path.dirname(bcpf_flags_file), exist_ok=True)
|
|
|
|
bcpf_flags_file_exists = os.path.exists(bcpf_flags_file)
|
|
|
|
matched_signatures = set()
|
|
# Open the flags file to read the flags from.
|
|
with open(flags_file, "r", encoding="utf8") as f:
|
|
# Open a temporary file to write the flags (minus any removed
|
|
# flags).
|
|
with open(tmp_flags_file, "w", encoding="utf8") as t:
|
|
# Open the bootclasspath_fragment file for append just in
|
|
# case it already exists.
|
|
with open(bcpf_flags_file, "a", encoding="utf8") as b:
|
|
for line in iter(f.readline, ""):
|
|
signature = line.rstrip()
|
|
if signature in self.signatures:
|
|
# The signature is provided by the
|
|
# bootclasspath_fragment so write it to the new
|
|
# bootclasspath_fragment specific file.
|
|
print(line, file=b, end="")
|
|
matched_signatures.add(signature)
|
|
else:
|
|
# The signature is NOT provided by the
|
|
# bootclasspath_fragment. Copy it to the new
|
|
# monolithic file.
|
|
print(line, file=t, end="")
|
|
|
|
# If the bootclasspath_fragment specific flags file is not empty
|
|
# then it contains flags. That could either be new flags just moved
|
|
# from frameworks/base or previous contents of the file. In either
|
|
# case the file must not be removed.
|
|
if matched_signatures:
|
|
# There are custom flags related to the bootclasspath_fragment
|
|
# so replace the frameworks/base/boot/hiddenapi file with the
|
|
# file that does not contain those flags.
|
|
shutil.move(tmp_flags_file, flags_file)
|
|
|
|
result.file_changes.append(
|
|
self.new_file_change(flags_file,
|
|
f"Removed '{self.bcpf}' specific entries"))
|
|
|
|
result.property_changes.append(
|
|
HiddenApiPropertyChange(
|
|
property_name=property_name,
|
|
values=[rel_bcpf_flags_file],
|
|
))
|
|
|
|
# Make sure that the files are sorted.
|
|
self.run_command([
|
|
"tools/platform-compat/hiddenapi/sort_api.sh",
|
|
bcpf_flags_file,
|
|
])
|
|
|
|
if bcpf_flags_file_exists:
|
|
desc = f"Added '{self.bcpf}' specific entries"
|
|
else:
|
|
desc = f"Created with '{self.bcpf}' specific entries"
|
|
result.file_changes.append(
|
|
self.new_file_change(bcpf_flags_file, desc))
|
|
else:
|
|
# There are no custom flags related to the
|
|
# bootclasspath_fragment so clean up the working files.
|
|
os.remove(tmp_flags_file)
|
|
if not bcpf_flags_file_exists:
|
|
os.remove(bcpf_flags_file)
|
|
|
|
def check_frameworks_base_boot_hidden_api_files(self, result):
|
|
hiddenapi_dir = os.path.join(self.top_dir,
|
|
"frameworks/base/boot/hiddenapi")
|
|
for basename in sorted(os.listdir(hiddenapi_dir)):
|
|
if not (basename.startswith("hiddenapi-") and
|
|
basename.endswith(".txt")):
|
|
continue
|
|
|
|
flags_file = os.path.join(hiddenapi_dir, basename)
|
|
|
|
logging.debug("Checking %s for flags related to %s", flags_file,
|
|
self.bcpf)
|
|
|
|
# Map the file name in frameworks/base/boot/hiddenapi into a
|
|
# slightly more meaningful name for use by the
|
|
# bootclasspath_fragment.
|
|
if basename == "hiddenapi-max-target-o.txt":
|
|
basename = "hiddenapi-max-target-o-low-priority.txt"
|
|
elif basename == "hiddenapi-max-target-r-loprio.txt":
|
|
basename = "hiddenapi-max-target-r-low-priority.txt"
|
|
|
|
property_name = basename.removeprefix("hiddenapi-")
|
|
property_name = property_name.removesuffix(".txt")
|
|
property_name = property_name.replace("-", "_")
|
|
|
|
rel_bcpf_flags_file = f"hiddenapi/{basename}"
|
|
bcpf_dir = self.module_info.module_path(self.bcpf)
|
|
bcpf_flags_file = os.path.join(self.top_dir, bcpf_dir,
|
|
rel_bcpf_flags_file)
|
|
|
|
if self.fix:
|
|
self.fix_hidden_api_flag_files(result, property_name,
|
|
flags_file, rel_bcpf_flags_file,
|
|
bcpf_flags_file)
|
|
else:
|
|
self.report_hidden_api_flag_file_changes(
|
|
result, property_name, flags_file, rel_bcpf_flags_file,
|
|
bcpf_flags_file)
|
|
|
|
@staticmethod
|
|
def split_package_comment(split_packages):
|
|
if split_packages:
|
|
return textwrap.dedent("""
|
|
The following packages contain classes from other modules on the
|
|
bootclasspath. That means that the hidden API flags for this
|
|
module has to explicitly list every single class this module
|
|
provides in that package to differentiate them from the classes
|
|
provided by other modules. That can include private classes that
|
|
are not part of the API.
|
|
""").strip("\n")
|
|
|
|
return "This module does not contain any split packages."
|
|
|
|
@staticmethod
|
|
def package_prefixes_comment():
|
|
return textwrap.dedent("""
|
|
The following packages and all their subpackages currently only
|
|
contain classes from this bootclasspath_fragment. Listing a package
|
|
here won't prevent other bootclasspath modules from adding classes
|
|
in any of those packages but it will prevent them from adding those
|
|
classes into an API surface, e.g. public, system, etc.. Doing so
|
|
will result in a build failure due to inconsistent flags.
|
|
""").strip("\n")
|
|
|
|
def analyze_hiddenapi_package_properties(self, result):
|
|
self.compute_hiddenapi_package_properties(result)
|
|
|
|
def indent_lines(lines):
|
|
return "\n".join([f" {cls}" for cls in lines])
|
|
|
|
# TODO(b/202154151): Find those classes in split packages that are not
|
|
# part of an API, i.e. are an internal implementation class, and so
|
|
# can, and should, be safely moved out of the split packages.
|
|
|
|
split_packages = result.split_packages.keys()
|
|
result.property_changes.append(
|
|
HiddenApiPropertyChange(
|
|
property_name="split_packages",
|
|
values=split_packages,
|
|
property_comment=self.split_package_comment(split_packages),
|
|
action=PropertyChangeAction.REPLACE,
|
|
))
|
|
|
|
if split_packages:
|
|
self.report_dedent(f"""
|
|
bootclasspath_fragment {self.bcpf} contains classes in packages
|
|
that also contain classes provided by other bootclasspath
|
|
modules. Those packages are called split packages. Split
|
|
packages should be avoided where possible but are often
|
|
unavoidable when modularizing existing code.
|
|
|
|
The hidden api processing needs to know which packages are split
|
|
(and conversely which are not) so that it can optimize the
|
|
hidden API flags to remove unnecessary implementation details.
|
|
|
|
By default (for backwards compatibility) the
|
|
bootclasspath_fragment assumes that all packages are split
|
|
unless one of the package_prefixes or split_packages properties
|
|
are specified. While that is safe it is not optimal and can lead
|
|
to unnecessary implementation details leaking into the hidden
|
|
API flags. Adding an empty split_packages property allows the
|
|
flags to be optimized and remove any unnecessary implementation
|
|
details.
|
|
""")
|
|
|
|
for package in split_packages:
|
|
reason = result.split_packages[package]
|
|
self.report(f"""
|
|
Package {package} is split because while this bootclasspath_fragment
|
|
provides the following classes:
|
|
{indent_lines(reason.bcpf)}
|
|
|
|
Other module(s) on the bootclasspath provides the following classes in
|
|
that package:
|
|
{indent_lines(reason.other)}
|
|
""")
|
|
|
|
single_packages = result.single_packages.keys()
|
|
if single_packages:
|
|
result.property_changes.append(
|
|
HiddenApiPropertyChange(
|
|
property_name="single_packages",
|
|
values=single_packages,
|
|
property_comment=textwrap.dedent("""
|
|
The following packages currently only contain classes from
|
|
this bootclasspath_fragment but some of their sub-packages
|
|
contain classes from other bootclasspath modules. Packages
|
|
should only be listed here when necessary for legacy
|
|
purposes, new packages should match a package prefix.
|
|
"""),
|
|
action=PropertyChangeAction.REPLACE,
|
|
))
|
|
|
|
self.report_dedent(f"""
|
|
bootclasspath_fragment {self.bcpf} contains classes from
|
|
packages that has sub-packages which contain classes provided by
|
|
other bootclasspath modules. Those packages are called single
|
|
packages. Single packages should be avoided where possible but
|
|
are often unavoidable when modularizing existing code.
|
|
|
|
Because some sub-packages contains classes from other
|
|
bootclasspath modules it is not possible to use the package as a
|
|
package prefix as that treats the package and all its
|
|
sub-packages as being provided by this module.
|
|
""")
|
|
for package in single_packages:
|
|
reason = result.single_packages[package]
|
|
self.report(f"""
|
|
Package {package} is not a package prefix because while this
|
|
bootclasspath_fragment provides the following sub-packages:
|
|
{indent_lines(reason.bcpf)}
|
|
|
|
Other module(s) on the bootclasspath provide the following sub-packages:
|
|
{indent_lines(reason.other)}
|
|
""")
|
|
|
|
package_prefixes = result.package_prefixes
|
|
if package_prefixes:
|
|
result.property_changes.append(
|
|
HiddenApiPropertyChange(
|
|
property_name="package_prefixes",
|
|
values=package_prefixes,
|
|
property_comment=self.package_prefixes_comment(),
|
|
action=PropertyChangeAction.REPLACE,
|
|
))
|
|
|
|
def explain_how_to_check_signature_patterns(self):
|
|
signature_patterns_files = self.find_bootclasspath_fragment_output_file(
|
|
"signature-patterns.csv", required=False)
|
|
if signature_patterns_files:
|
|
signature_patterns_files = signature_patterns_files.removeprefix(
|
|
self.top_dir)
|
|
|
|
self.report_dedent(f"""
|
|
The purpose of the hiddenapi split_packages and package_prefixes
|
|
properties is to allow the removal of implementation details
|
|
from the hidden API flags to reduce the coupling between sdk
|
|
snapshots and the APEX runtime. It cannot eliminate that
|
|
coupling completely though. Doing so may require changes to the
|
|
code.
|
|
|
|
This tool provides support for managing those properties but it
|
|
cannot decide whether the set of package prefixes suggested is
|
|
appropriate that needs the input of the developer.
|
|
|
|
Please run the following command:
|
|
m {signature_patterns_files}
|
|
|
|
And then check the '{signature_patterns_files}' for any mention
|
|
of implementation classes and packages (i.e. those
|
|
classes/packages that do not contain any part of an API surface,
|
|
including the hidden API). If they are found then the code
|
|
should ideally be moved to a package unique to this module that
|
|
is contained within a package that is part of an API surface.
|
|
|
|
The format of the file is a list of patterns:
|
|
|
|
* Patterns for split packages will list every class in that package.
|
|
|
|
* Patterns for package prefixes will end with .../**.
|
|
|
|
* Patterns for packages which are not split but cannot use a
|
|
package prefix because there are sub-packages which are provided
|
|
by another module will end with .../*.
|
|
""")
|
|
|
|
def compute_hiddenapi_package_properties(self, result):
|
|
trie = signature_trie()
|
|
# Populate the trie with the classes that are provided by the
|
|
# bootclasspath_fragment tagging them to make it clear where they
|
|
# are from.
|
|
sorted_classes = sorted(self.classes)
|
|
for class_name in sorted_classes:
|
|
trie.add(class_name + _FAKE_MEMBER, ClassProvider.BCPF)
|
|
|
|
# Now the same for monolithic classes.
|
|
monolithic_classes = set()
|
|
abs_flags_file = os.path.join(self.top_dir, _FLAGS_FILE)
|
|
with open(abs_flags_file, "r", encoding="utf8") as f:
|
|
for line in iter(f.readline, ""):
|
|
signature = self.line_to_signature(line)
|
|
class_name = self.signature_to_class(signature)
|
|
if (class_name not in monolithic_classes and
|
|
class_name not in self.classes):
|
|
trie.add(
|
|
class_name + _FAKE_MEMBER,
|
|
ClassProvider.OTHER,
|
|
only_if_matches=True)
|
|
monolithic_classes.add(class_name)
|
|
|
|
self.recurse_hiddenapi_packages_trie(trie, result)
|
|
|
|
@staticmethod
|
|
def selector_to_java_reference(node):
|
|
return node.selector.replace("/", ".")
|
|
|
|
@staticmethod
|
|
def determine_reason_for_single_package(node):
|
|
bcpf_packages = []
|
|
other_packages = []
|
|
|
|
def recurse(n):
|
|
if n.type != "package":
|
|
return
|
|
|
|
providers = n.get_matching_rows("*")
|
|
package_ref = BcpfAnalyzer.selector_to_java_reference(n)
|
|
if ClassProvider.BCPF in providers:
|
|
bcpf_packages.append(package_ref)
|
|
else:
|
|
other_packages.append(package_ref)
|
|
|
|
children = n.child_nodes()
|
|
if children:
|
|
for child in children:
|
|
recurse(child)
|
|
|
|
recurse(node)
|
|
return PackagePropertyReason(bcpf=bcpf_packages, other=other_packages)
|
|
|
|
@staticmethod
|
|
def determine_reason_for_split_package(node):
|
|
bcpf_classes = []
|
|
other_classes = []
|
|
for child in node.child_nodes():
|
|
if child.type != "class":
|
|
continue
|
|
|
|
providers = child.values(lambda _: True)
|
|
class_ref = BcpfAnalyzer.selector_to_java_reference(child)
|
|
if ClassProvider.BCPF in providers:
|
|
bcpf_classes.append(class_ref)
|
|
else:
|
|
other_classes.append(class_ref)
|
|
|
|
return PackagePropertyReason(bcpf=bcpf_classes, other=other_classes)
|
|
|
|
def recurse_hiddenapi_packages_trie(self, node, result):
|
|
nodes = node.child_nodes()
|
|
if nodes:
|
|
for child in nodes:
|
|
# Ignore any non-package nodes.
|
|
if child.type != "package":
|
|
continue
|
|
|
|
package = self.selector_to_java_reference(child)
|
|
|
|
providers = set(child.get_matching_rows("**"))
|
|
if not providers:
|
|
# The package and all its sub packages contain no
|
|
# classes. This should never happen.
|
|
pass
|
|
elif providers == {ClassProvider.BCPF}:
|
|
# The package and all its sub packages only contain
|
|
# classes provided by the bootclasspath_fragment.
|
|
logging.debug("Package '%s.**' is not split", package)
|
|
result.package_prefixes.append(package)
|
|
# There is no point traversing into the sub packages.
|
|
continue
|
|
elif providers == {ClassProvider.OTHER}:
|
|
# The package and all its sub packages contain no
|
|
# classes provided by the bootclasspath_fragment.
|
|
# There is no point traversing into the sub packages.
|
|
logging.debug("Package '%s.**' contains no classes from %s",
|
|
package, self.bcpf)
|
|
continue
|
|
elif ClassProvider.BCPF in providers:
|
|
# The package and all its sub packages contain classes
|
|
# provided by the bootclasspath_fragment and other
|
|
# sources.
|
|
logging.debug(
|
|
"Package '%s.**' contains classes from "
|
|
"%s and other sources", package, self.bcpf)
|
|
|
|
providers = set(child.get_matching_rows("*"))
|
|
if not providers:
|
|
# The package contains no classes.
|
|
logging.debug("Package: %s contains no classes", package)
|
|
elif providers == {ClassProvider.BCPF}:
|
|
# The package only contains classes provided by the
|
|
# bootclasspath_fragment.
|
|
logging.debug(
|
|
"Package '%s.*' is not split but does have "
|
|
"sub-packages from other modules", package)
|
|
|
|
# Partition the sub-packages into those that are provided by
|
|
# this bootclasspath_fragment and those provided by other
|
|
# modules. They can be used to explain the reason for the
|
|
# single package to developers.
|
|
reason = self.determine_reason_for_single_package(child)
|
|
result.single_packages[package] = reason
|
|
|
|
elif providers == {ClassProvider.OTHER}:
|
|
# The package contains no classes provided by the
|
|
# bootclasspath_fragment. Child nodes make contain such
|
|
# classes.
|
|
logging.debug("Package '%s.*' contains no classes from %s",
|
|
package, self.bcpf)
|
|
elif ClassProvider.BCPF in providers:
|
|
# The package contains classes provided by both the
|
|
# bootclasspath_fragment and some other source.
|
|
logging.debug("Package '%s.*' is split", package)
|
|
|
|
# Partition the classes in this split package into those
|
|
# that come from this bootclasspath_fragment and those that
|
|
# come from other modules. That can be used to explain the
|
|
# reason for the split package to developers.
|
|
reason = self.determine_reason_for_split_package(child)
|
|
result.split_packages[package] = reason
|
|
|
|
self.recurse_hiddenapi_packages_trie(child, result)
|
|
|
|
|
|
def newline_stripping_iter(iterator):
|
|
"""Return an iterator over the iterator that strips trailing white space."""
|
|
lines = iter(iterator, "")
|
|
lines = (line.rstrip() for line in lines)
|
|
return lines
|
|
|
|
|
|
def format_comment_as_text(text, indent):
|
|
return "".join(
|
|
[f"{line}\n" for line in format_comment_as_lines(text, indent)])
|
|
|
|
|
|
def format_comment_as_lines(text, indent):
|
|
lines = textwrap.wrap(text.strip("\n"), width=77 - len(indent))
|
|
lines = [f"{indent}// {line}" for line in lines]
|
|
return lines
|
|
|
|
|
|
def log_stream_for_subprocess():
|
|
stream = subprocess.DEVNULL
|
|
for handler in logging.root.handlers:
|
|
if handler.level == logging.DEBUG:
|
|
if isinstance(handler, logging.StreamHandler):
|
|
stream = handler.stream
|
|
return stream
|
|
|
|
|
|
def main(argv):
|
|
args_parser = argparse.ArgumentParser(
|
|
description="Analyze a bootclasspath_fragment module.")
|
|
args_parser.add_argument(
|
|
"--bcpf",
|
|
help="The bootclasspath_fragment module to analyze",
|
|
required=True,
|
|
)
|
|
args_parser.add_argument(
|
|
"--apex",
|
|
help="The apex module to which the bootclasspath_fragment belongs. It "
|
|
"is not strictly necessary at the moment but providing it will "
|
|
"allow this script to give more useful messages and it may be"
|
|
"required in future.",
|
|
default="SPECIFY-APEX-OPTION")
|
|
args_parser.add_argument(
|
|
"--sdk",
|
|
help="The sdk module to which the bootclasspath_fragment belongs. It "
|
|
"is not strictly necessary at the moment but providing it will "
|
|
"allow this script to give more useful messages and it may be"
|
|
"required in future.",
|
|
default="SPECIFY-SDK-OPTION")
|
|
args_parser.add_argument(
|
|
"--fix",
|
|
help="Attempt to fix any issues found automatically.",
|
|
action="store_true",
|
|
default=False)
|
|
args = args_parser.parse_args(argv[1:])
|
|
top_dir = os.environ["ANDROID_BUILD_TOP"] + "/"
|
|
out_dir = os.environ.get("OUT_DIR", os.path.join(top_dir, "out"))
|
|
product_out_dir = os.environ.get("ANDROID_PRODUCT_OUT", top_dir)
|
|
# Make product_out_dir relative to the top so it can be used as part of a
|
|
# build target.
|
|
product_out_dir = product_out_dir.removeprefix(top_dir)
|
|
log_fd, abs_log_file = tempfile.mkstemp(
|
|
suffix="_analyze_bcpf.log", text=True)
|
|
|
|
with os.fdopen(log_fd, "w") as log_file:
|
|
# Set up debug logging to the log file.
|
|
logging.basicConfig(
|
|
level=logging.DEBUG,
|
|
format="%(levelname)-8s %(message)s",
|
|
stream=log_file)
|
|
|
|
# define a Handler which writes INFO messages or higher to the
|
|
# sys.stdout with just the message.
|
|
console = logging.StreamHandler()
|
|
console.setLevel(logging.INFO)
|
|
console.setFormatter(logging.Formatter("%(message)s"))
|
|
# add the handler to the root logger
|
|
logging.getLogger("").addHandler(console)
|
|
|
|
print(f"Writing log to {abs_log_file}")
|
|
try:
|
|
analyzer = BcpfAnalyzer(
|
|
tool_path=argv[0],
|
|
top_dir=top_dir,
|
|
out_dir=out_dir,
|
|
product_out_dir=product_out_dir,
|
|
bcpf=args.bcpf,
|
|
apex=args.apex,
|
|
sdk=args.sdk,
|
|
fix=args.fix,
|
|
)
|
|
analyzer.analyze()
|
|
finally:
|
|
print(f"Log written to {abs_log_file}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main(sys.argv)
|