| #!/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) |
