Quelle  soong_lint_fix.py

#  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.

import argparse
import json
import functools
import os
import shutil
import subprocess
import sys
import zipfile

ANDROID_BUILD_TOP = os.environ.get("ANDROID_BUILD_TOP")
ANDROID_PRODUCT_OUT = os.environ.get("ANDROID_PRODUCT_OUT")
PRODUCT_OUT = ANDROID_PRODUCT_OUT.removeprefix(f"{ANDROID_BUILD_TOP}/")

SOONG_UI = "build/soong/soong_ui.bash"
PATH_PREFIX = "out/soong/.intermediates"
PATH_SUFFIX = "android_common/lint"
FIX_ZIP = "suggested-fixes.zip"
MODULE_JAVA_DEPS = "out/soong/module_bp_java_deps.json"


class SoongModule:
    """A Soong module to lint.

    The constructor takes the name of the module (for example,
    "framework-minus-apex"). find() must be called to extract the intermediate
    module path using aninja.
    """
    def __init__(self, name):
        self._name = name

    def find(self):
        """Finds the module path using aninja."""
        print(f"Finding module {self._name} with aninja...")
        try:
            cmd = ["aninja", "-t", "query", f"{self._name}-lint"]
            result = subprocess.run(
                cmd,
                capture_output=True,
                text=True,
                check=True,
                cwd=ANDROID_BUILD_TOP)

            output = result.stdout
            lines = output.splitlines()

            try:
                input_phony_index = next(
                    i for i, line in enumerate(lines)
                    if line.strip() == "input: phony")
            except StopIteration:
                raise Exception(
                    f"Could not find 'input: phony' in aninja output for {self._name}-lint\nOutput:\n{output}"
                )

            if input_phony_index + 1 >= len(lines):
                raise Exception(
                    f"No path found after 'input: phony' for {self._name}-lint")

            path_line = lines[input_phony_index + 1].strip()
            module_path = os.path.dirname(path_line)

            print(f"Found module {self._name} path: {module_path}.")
            self._path = module_path
        except FileNotFoundError:
            raise Exception(
                "`aninja` not found. Make sure you have run `m aninja` and it is in your PATH."
            )
        except subprocess.CalledProcessError as e:
            raise Exception(
                f"aninja failed for module {self._name}-lint:\n{e.stderr}")

    def find_java_deps(self, module_java_deps):
        """Finds the dependencies of a Java module in the loaded module_bp_java_deps.json.

        Returns:
            A list of module names.
        """
        if self._name not in module_java_deps:
            raise Exception(f"Module {self._name} not found!")

        return module_java_deps[self._name]["dependencies"]

    @property
    def name(self):
        return self._name

    @property
    def path(self):
        return self._path

    @property
    def lint_report(self):
        return f"{self._path}/lint-report.txt"

    @property
    def suggested_fixes(self):
        return f"{self._path}/{FIX_ZIP}"


class SoongLintWrapper:
    """
    This class wraps the necessary calls to Soong and/or shell commands to lint
    platform modules and apply suggested fixes if desired.

    It breaks up these operations into a few methods that are available to
    sub-classes (see SoongLintFix for an example).
    """
    def __init__(self, check=None, lint_module=None):
        self._check = check
        self._lint_module = lint_module
        self._kwargs = None

    def _setup(self):
        env = os.environ.copy()
        if self._check:
            env["ANDROID_LINT_CHECK"] = self._check
        if self._lint_module:
            env["ANDROID_LINT_CHECK_EXTRA_MODULES"] = self._lint_module

        self._kwargs = {
            "env": env,
            "executable": "/bin/bash",
            "shell": True,
        }

        os.chdir(ANDROID_BUILD_TOP)

    def _find_module(self, module_name):
        """Returns a SoongModule from a module name.

        Ensures that the module is known to Soong.
        """
        module = SoongModule(module_name)
        module.find()
        return module

    def _find_modules(self, module_names):
        modules = []
        for module_name in module_names:
            modules.append(self._find_module(module_name))
        return modules

    @functools.cached_property
    def _module_java_deps(self):
        """Returns the JSON content of module_bp_java_deps.json."""
        print("Refreshing Soong Java deps...")
        subprocess.call(f"{SOONG_UI} --make-mode {MODULE_JAVA_DEPS}", **self._kwargs)
        print("done.")

        with open(f"{MODULE_JAVA_DEPS}") as f:
            return json.load(f)

    def _find_module_java_deps(self, module):
        """Returns a list a dependencies for a module.

        Args:
            module: A SoongModule.

        Returns:
            A list of SoongModule.
        """
        deps = []
        dep_names = module.find_java_deps(self._module_java_deps)
        for dep_name in dep_names:
            dep = SoongModule(dep_name)
            dep.find()
            deps.append(dep)
        return deps

    def _lint(self, modules):
        print("Cleaning up any old lint results...")
        for module in modules:
            try:
                os.remove(f"{module.lint_report}")
                os.remove(f"{module.suggested_fixes}")
            except FileNotFoundError:
                pass
        print("done.")

        target = " ".join([ module.lint_report for module in modules ])
        print(f"Generating {target}")
        subprocess.call(f"{SOONG_UI} --make-mode {target}", **self._kwargs)
        print("done.")

    def _fix(self, modules):
        for module in modules:
            print(f"Copying suggested fixes for {module.name} to the tree...")
            with zipfile.ZipFile(f"{module.suggested_fixes}") as zip:
                for name in zip.namelist():
                    if name.startswith("out") or not name.endswith(".java"):
                        continue
                    with zip.open(name) as src, open(f"{ANDROID_BUILD_TOP}/{name}", "wb") as dst:
                        shutil.copyfileobj(src, dst)
            print("done.")

    def _print(self, modules):
        for module in modules:
            print(f"### lint-report.txt {module.name} ###", end="\n\n")
            with open(module.lint_report, "r") as f:
                print(f.read())


class SoongLintFix(SoongLintWrapper):
    """
    Basic usage:
    ```
    from soong_lint_fix import SoongLintFix

    opts = SoongLintFixOptions()
    opts.parse_args()
    SoongLintFix(opts).run()
    ```
    """
    def __init__(self, opts):
        super().__init__(check=opts.check, lint_module=opts.lint_module)
        self._opts = opts

    def run(self):
        self._setup()
        modules = self._find_modules(self._opts.modules)
        self._lint(modules)

        if not self._opts.no_fix:
            self._fix(modules)

        if self._opts.print:
            self._print(modules)


class SoongLintFixOptions:
    """Options for SoongLintFix"""

    def __init__(self):
        self.modules = []
        self.check = None
        self.lint_module = None
        self.no_fix = False
        self.print = False

    def parse_args(self, args=None):
        _setup_parser().parse_args(args, self)


def _setup_parser():
    parser = argparse.ArgumentParser(description="""
        This is a python script that applies lint fixes to the platform:
        1. Set up the environment, etc.
        2. Run lint on the specified target.
        3. Copy the modified files, from soong's intermediate directory, back into the tree.

        **Gotcha**: You must have run `source build/envsetup.sh` and `lunch` first.
        """, formatter_class=argparse.RawTextHelpFormatter)

    parser.add_argument('modules',
                        nargs='+',
                        help='The soong build module to run '
                             '(e.g. framework-minus-apex or services.core.unboosted)')

    parser.add_argument('--check',
                        help='Which lint to run. Passed to the ANDROID_LINT_CHECK environment variable.')

    parser.add_argument('--lint-module',
                            help='Specific lint module to run. Passed to the ANDROID_LINT_CHECK_EXTRA_MODULES environment variable.')

    parser.add_argument('--no-fix', action='store_true',
                        help='Just build and run the lint, do NOT apply the fixes.')

    parser.add_argument('--print', action='store_true',
                        help='Print the contents of the generated lint-report.txt at the end.')

    return parser

if __name__ == "__main__":
    opts = SoongLintFixOptions()
    opts.parse_args()
    SoongLintFix(opts).run()