xref: /tools/asuite/aidegen/lib/project_info.py

#!/usr/bin/env python3
#
# Copyright 2018 - 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.

"""Project information."""

from __future__ import absolute_import

import logging
import os

from aidegen import constant
from aidegen.lib import common_util
from aidegen.lib import errors
from aidegen.lib import module_info
from aidegen.lib import project_config
from aidegen.lib import source_locator

from atest import atest_utils

_CONVERT_MK_URL = ('https://android.googlesource.com/platform/build/soong/'
                   '#convert-android_mk-files')
_ANDROID_MK_WARN = (
    '{} contains Android.mk file(s) in its dependencies:\n{}\nPlease help '
    'convert these files into blueprint format in the future, otherwise '
    'AIDEGen may not be able to include all module dependencies.\nPlease visit '
    '%s for reference on how to convert makefile.' % _CONVERT_MK_URL)
_ROBOLECTRIC_MODULE = 'Robolectric_all'
_NOT_TARGET = ('Module %s\'s class setting is %s, none of which is included in '
               '%s, skipping this module in the project.')
# The module fake-framework have the same package name with framework but empty
# content. It will impact the dependency for framework when referencing the
# package from fake-framework in IntelliJ.
_EXCLUDE_MODULES = ['fake-framework']
# When we use atest_utils.build(), there is a command length limit on
# soong_ui.bash. We reserve 5000 characters for rewriting the command line
# in soong_ui.bash.
_CMD_LENGTH_BUFFER = 5000
# For each argument, it need a space to separate following argument.
_BLANK_SIZE = 1
_CORE_MODULES = [constant.FRAMEWORK_ALL, constant.CORE_ALL,
                 'org.apache.http.legacy.stubs.system']


class ProjectInfo:
    """Project information.

    Users should call config_project first before starting using ProjectInfo.

    Class attributes:
        modules_info: An AidegenModuleInfo instance whose name_to_module_info is
                      combining module-info.json with module_bp_java_deps.json.

    Attributes:
        project_absolute_path: The absolute path of the project.
        project_relative_path: The relative path of the project to
                               common_util.get_android_root_dir().
        project_module_names: A set of module names under project_absolute_path
                              directory or it's subdirectories.
        dep_modules: A dict has recursively dependent modules of
                     project_module_names.
        iml_path: The project's iml file path.
        source_path: A dictionary to keep following data:
                     source_folder_path: A set contains the source folder
                                         relative paths.
                     test_folder_path: A set contains the test folder relative
                                       paths.
                     jar_path: A set contains the jar file paths.
                     jar_module_path: A dictionary contains the jar file and
                                      the module's path mapping, only used in
                                      Eclipse.
                     r_java_path: A set contains the relative path to the
                                  R.java files, only used in Eclipse.
                     srcjar_path: A source content descriptor only used in
                                  IntelliJ.
                                  e.g. out/.../aapt2.srcjar!/
                                  The "!/" is a content descriptor for
                                  compressed files in IntelliJ.
        is_main_project: A boolean to verify the project is main project.
        dependencies: A list of dependency projects' iml file names, e.g. base,
                      framework-all.
    """

    modules_info = None

    def __init__(self, target=None, is_main_project=False):
        """ProjectInfo initialize.

        Args:
            target: Includes target module or project path from user input, when
                    locating the target, project with matching module name of
                    the given target has a higher priority than project path.
            is_main_project: A boolean, default is False. True if the target is
                             the main project, otherwise False.
        """
        rel_path, abs_path = common_util.get_related_paths(
            self.modules_info, target)
        self.module_name = self.get_target_name(target, abs_path)
        self.is_main_project = is_main_project
        self.project_module_names = set(
            self.modules_info.get_module_names(rel_path))
        self.project_relative_path = rel_path
        self.project_absolute_path = abs_path
        self.iml_path = ''
        self._set_default_modues()
        self._init_source_path()
        if target == constant.FRAMEWORK_ALL:
            self.dep_modules = self.get_dep_modules([target])
        else:
            self.dep_modules = self.get_dep_modules()
        self._filter_out_modules()
        self._display_convert_make_files_message()
        self.dependencies = []

    def _set_default_modues(self):
        """Append default hard-code modules, source paths and jar files.

        1. framework: Framework module is always needed for dependencies but it
            might not always be located by module dependency.
        2. org.apache.http.legacy.stubs.system: The module can't be located
            through module dependency. Without it, a lot of java files will have
            error of "cannot resolve symbol" in IntelliJ since they import
            packages android.Manifest and com.android.internal.R.
        """
        # Set the default modules framework-all and core-all as the core
        # dependency modules.
        self.project_module_names.update(_CORE_MODULES)

    def _init_source_path(self):
        """Initialize source_path dictionary."""
        self.source_path = {
            'source_folder_path': set(),
            'test_folder_path': set(),
            'jar_path': set(),
            'jar_module_path': dict(),
            'r_java_path': set(),
            'srcjar_path': set()
        }

    def _display_convert_make_files_message(self):
        """Show message info users convert their Android.mk to Android.bp."""
        mk_set = set(self._search_android_make_files())
        if mk_set:
            print('\n{} {}\n'.format(
                common_util.COLORED_INFO('Warning:'),
                _ANDROID_MK_WARN.format(self.module_name, '\n'.join(mk_set))))

    def _search_android_make_files(self):
        """Search project and dependency modules contain Android.mk files.

        If there is only Android.mk but no Android.bp, we'll show the warning
        message, otherwise we won't.

        Yields:
            A string: the relative path of Android.mk.
        """
        if (common_util.exist_android_mk(self.project_absolute_path) and
                not common_util.exist_android_bp(self.project_absolute_path)):
            yield '\t' + os.path.join(self.project_relative_path,
                                      constant.ANDROID_MK)
        for mod_name in self.dep_modules:
            rel_path, abs_path = common_util.get_related_paths(
                self.modules_info, mod_name)
            if rel_path and abs_path:
                if (common_util.exist_android_mk(abs_path)
                        and not common_util.exist_android_bp(abs_path)):
                    yield '\t' + os.path.join(rel_path, constant.ANDROID_MK)

    def _get_modules_under_project_path(self, rel_path):
        """Find modules under the rel_path.

        Find modules whose class is qualified to be included as a target module.

        Args:
            rel_path: A string, the project's relative path.

        Returns:
            A set of module names.
        """
        logging.info('Find modules whose class is in %s under %s.',
                     constant.TARGET_CLASSES, rel_path)
        modules = set()
        for name, data in self.modules_info.name_to_module_info.items():
            if module_info.AidegenModuleInfo.is_project_path_relative_module(
                    data, rel_path):
                if module_info.AidegenModuleInfo.is_target_module(data):
                    modules.add(name)
                else:
                    logging.debug(_NOT_TARGET, name, data.get('class', ''),
                                  constant.TARGET_CLASSES)
        return modules

    def _get_robolectric_dep_module(self, modules):
        """Return the robolectric module set as dependency if any module is a
           robolectric test.

        Args:
            modules: A set of modules.

        Returns:
            A set with a robolectric_all module name if one of the modules
            needs the robolectric test module. Otherwise return empty list.
        """
        for module in modules:
            if self.modules_info.is_robolectric_test(module):
                return {_ROBOLECTRIC_MODULE}
        return set()

    def _filter_out_modules(self):
        """Filter out unnecessary modules."""
        for module in _EXCLUDE_MODULES:
            self.dep_modules.pop(module, None)

    def get_dep_modules(self, module_names=None, depth=0):
        """Recursively find dependent modules of the project.

        Find dependent modules by dependencies parameter of each module.
        For example:
            The module_names is ['m1'].
            The modules_info is
            {
                'm1': {'dependencies': ['m2'], 'path': ['path_to_m1']},
                'm2': {'path': ['path_to_m4']},
                'm3': {'path': ['path_to_m1']}
                'm4': {'path': []}
            }
            The result dependent modules are:
            {
                'm1': {'dependencies': ['m2'], 'path': ['path_to_m1']
                       'depth': 0},
                'm2': {'path': ['path_to_m4'], 'depth': 1},
                'm3': {'path': ['path_to_m1'], 'depth': 0}
            }
            Note that:
                1. m4 is not in the result as it's not among dependent modules.
                2. m3 is in the result as it has the same path to m1.

        Args:
            module_names: A set of module names.
            depth: An integer shows the depth of module dependency referenced by
                   source. Zero means the max module depth.

        Returns:
            deps: A dict contains all dependent modules data of given modules.
        """
        dep = {}
        children = set()
        if not module_names:
            module_names = self.project_module_names
            module_names.update(
                self._get_modules_under_project_path(
                    self.project_relative_path))
            module_names.update(self._get_robolectric_dep_module(module_names))
            self.project_module_names = set()
        for name in module_names:
            if (name in self.modules_info.name_to_module_info
                    and name not in self.project_module_names):
                dep[name] = self.modules_info.name_to_module_info[name]
                dep[name][constant.KEY_DEPTH] = depth
                self.project_module_names.add(name)
                if (constant.KEY_DEPENDENCIES in dep[name]
                        and dep[name][constant.KEY_DEPENDENCIES]):
                    children.update(dep[name][constant.KEY_DEPENDENCIES])
        if children:
            dep.update(self.get_dep_modules(children, depth + 1))
        return dep

    @staticmethod
    def generate_projects(targets):
        """Generate a list of projects in one time by a list of module names.

        Args:
            targets: A list of target modules or project paths from user input,
                     when locating the target, project with matched module name
                     of the target has a higher priority than project path.

        Returns:
            List: A list of ProjectInfo instances.
        """
        return [ProjectInfo(target, i == 0) for i, target in enumerate(targets)]

    @staticmethod
    def get_target_name(target, abs_path):
        """Get target name from target's absolute path.

        If the project is for entire Android source tree, change the target to
        source tree's root folder name. In this way, we give IDE project file
        a more specific name. e.g, master.iml.

        Args:
            target: Includes target module or project path from user input, when
                    locating the target, project with matching module name of
                    the given target has a higher priority than project path.
            abs_path: A string, target's absolute path.

        Returns:
            A string, the target name.
        """
        if abs_path == common_util.get_android_root_dir():
            return os.path.basename(abs_path)
        return target

    def locate_source(self, build=True):
        """Locate the paths of dependent source folders and jar files.

        Try to reference source folder path as dependent module unless the
        dependent module should be referenced to a jar file, such as modules
        have jars and jarjar_rules parameter.
        For example:
            Module: asm-6.0
                java_import {
                    name: 'asm-6.0',
                    host_supported: true,
                    jars: ['asm-6.0.jar'],
                }
            Module: bouncycastle
                java_library {
                    name: 'bouncycastle',
                    ...
                    target: {
                        android: {
                            jarjar_rules: 'jarjar-rules.txt',
                        },
                    },
                }

        Args:
            build: A boolean default to true. If false, skip building jar and
                   srcjar files, otherwise build them.

        Example usage:
            project.source_path = project.locate_source()
            E.g.
                project.source_path = {
                    'source_folder_path': ['path/to/source/folder1',
                                           'path/to/source/folder2', ...],
                    'test_folder_path': ['path/to/test/folder', ...],
                    'jar_path': ['path/to/jar/file1', 'path/to/jar/file2', ...]
                }
        """
        if not hasattr(self, 'dep_modules') or not self.dep_modules:
            raise errors.EmptyModuleDependencyError(
                'Dependent modules dictionary is empty.')
        rebuild_targets = set()
        for module_name, module_data in self.dep_modules.items():
            module = self._generate_moduledata(module_name, module_data)
            module.locate_sources_path()
            self.source_path['source_folder_path'].update(set(module.src_dirs))
            self.source_path['test_folder_path'].update(set(module.test_dirs))
            self.source_path['r_java_path'].update(set(module.r_java_paths))
            self.source_path['srcjar_path'].update(set(module.srcjar_paths))
            self._append_jars_as_dependencies(module)
            rebuild_targets.update(module.build_targets)
        config = project_config.ProjectConfig.get_instance()
        if config.is_skip_build:
            return
        if rebuild_targets:
            if build:
                logging.info('\nThe batch_build_dependencies function is '
                             'called by ProjectInfo\'s locate_source method.')
                batch_build_dependencies(rebuild_targets)
                self.locate_source(build=False)
            else:
                logging.warning('Jar or srcjar files build skipped:\n\t%s.',
                                '\n\t'.join(rebuild_targets))

    def _generate_moduledata(self, module_name, module_data):
        """Generate a module class to collect dependencies in IDE.

        The rules of initialize a module data instance: if ide_object isn't None
        and its ide_name is 'eclipse', we'll create an EclipseModuleData
        instance otherwise create a ModuleData instance.

        Args:
            module_name: Name of the module.
            module_data: A dictionary holding a module information.

        Returns:
            A ModuleData class.
        """
        ide_name = project_config.ProjectConfig.get_instance().ide_name
        if ide_name == constant.IDE_ECLIPSE:
            return source_locator.EclipseModuleData(
                module_name, module_data, self.project_relative_path)
        depth = project_config.ProjectConfig.get_instance().depth
        return source_locator.ModuleData(module_name, module_data, depth)

    def _append_jars_as_dependencies(self, module):
        """Add given module's jar files into dependent_data as dependencies.

        Args:
            module: A ModuleData instance.
        """
        if module.jar_files:
            self.source_path['jar_path'].update(module.jar_files)
            for jar in list(module.jar_files):
                self.source_path['jar_module_path'].update({
                    jar:
                    module.module_path
                })
        # Collecting the jar files of default core modules as dependencies.
        if constant.KEY_DEPENDENCIES in module.module_data:
            self.source_path['jar_path'].update([
                x for x in module.module_data[constant.KEY_DEPENDENCIES]
                if common_util.is_target(x, constant.TARGET_LIBS)
            ])

    @classmethod
    def multi_projects_locate_source(cls, projects):
        """Locate the paths of dependent source folders and jar files.

        Args:
            projects: A list of ProjectInfo instances. Information of a project
                      such as project relative path, project real path, project
                      dependencies.
        """
        for project in projects:
            project.locate_source()


class MultiProjectsInfo(ProjectInfo):
    """Multiple projects info.

    Usage example:
        if folder_base:
            project = MultiProjectsInfo(['module_name'])
            project.collect_all_dep_modules()
            project.gen_folder_base_dependencies()
        else:
            ProjectInfo.generate_projects(['module_name'])

    Attributes:
        _targets: A list of module names or project paths.
        path_to_sources: A dictionary of modules' sources, the module's path
                         as key and the sources as value.
                         e.g.
                         {
                             'frameworks/base': {
                                 'src_dirs': [],
                                 'test_dirs': [],
                                 'r_java_paths': [],
                                 'srcjar_paths': [],
                                 'jar_files': [],
                                 'dep_paths': [],
                             }
                         }
    """

    def __init__(self, targets=None):
        """MultiProjectsInfo initialize.

        Args:
            targets: A list of module names or project paths from user's input.
        """
        super().__init__(targets[0], True)
        self._targets = targets
        self.path_to_sources = {}

    def _clear_srcjar_paths(self, module):
        """Clears the srcjar_paths.

        Args:
            module: A ModuleData instance.
        """
        module.srcjar_paths = []

    def _collect_framework_srcjar_info(self, module):
        """Clears the framework's srcjars.

        Args:
            module: A ModuleData instance.
        """
        if module.module_path == constant.FRAMEWORK_PATH:
            framework_srcjar_path = os.path.join(constant.FRAMEWORK_PATH,
                                                 constant.FRAMEWORK_SRCJARS)
            if module.module_name == constant.FRAMEWORK_ALL:
                self.path_to_sources[framework_srcjar_path] = {
                    'src_dirs': [],
                    'test_dirs': [],
                    'r_java_paths': [],
                    'srcjar_paths': module.srcjar_paths,
                    'jar_files': [],
                    'dep_paths': [constant.FRAMEWORK_PATH],
                }
            # In the folder base case, AIDEGen has to ignore all module's srcjar
            # files under the frameworks/base except the framework-all. Because
            # there are too many duplicate srcjars of modules under the
            # frameworks/base. So that AIDEGen keeps the srcjar files only from
            # the framework-all module. Other modeuls' srcjar files will be
            # removed. However, when users choose the module base case, srcjar
            # files will be collected by the ProjectInfo class, so that the
            # removing srcjar_paths in this class does not impact the
            # srcjar_paths collection of modules in the ProjectInfo class.
            self._clear_srcjar_paths(module)

    def collect_all_dep_modules(self):
        """Collects all dependency modules for the projects."""
        self.project_module_names.clear()
        module_names = set(_CORE_MODULES)
        for target in self._targets:
            relpath, _ = common_util.get_related_paths(self.modules_info,
                                                       target)
            module_names.update(self._get_modules_under_project_path(relpath))
        module_names.update(self._get_robolectric_dep_module(module_names))
        self.dep_modules = self.get_dep_modules(module_names)

    def gen_folder_base_dependencies(self, module):
        """Generates the folder base dependencies dictionary.

        Args:
            module: A ModuleData instance.
        """
        mod_path = module.module_path
        if not mod_path:
            logging.debug('The %s\'s path is empty.', module.module_name)
            return
        self._collect_framework_srcjar_info(module)
        if mod_path not in self.path_to_sources:
            self.path_to_sources[mod_path] = {
                'src_dirs': module.src_dirs,
                'test_dirs': module.test_dirs,
                'r_java_paths': module.r_java_paths,
                'srcjar_paths': module.srcjar_paths,
                'jar_files': module.jar_files,
                'dep_paths': module.dep_paths,
            }
        else:
            for key, val in self.path_to_sources[mod_path].items():
                val.extend([v for v in getattr(module, key) if v not in val])


def batch_build_dependencies(rebuild_targets):
    """Batch build the jar or srcjar files of the modules if they don't exist.

    Command line has the max length limit, MAX_ARG_STRLEN, and
    MAX_ARG_STRLEN = (PAGE_SIZE * 32).
    If the build command is longer than MAX_ARG_STRLEN, this function will
    separate the rebuild_targets into chunks with size less or equal to
    MAX_ARG_STRLEN to make sure it can be built successfully.

    Args:
        rebuild_targets: A set of jar or srcjar files which do not exist.
    """
    logging.info('Ready to build the jar or srcjar files. Files count = %s',
                 str(len(rebuild_targets)))
    arg_max = os.sysconf('SC_PAGE_SIZE') * 32 - _CMD_LENGTH_BUFFER
    rebuild_targets = list(rebuild_targets)
    for start, end in iter(_separate_build_targets(rebuild_targets, arg_max)):
        _build_target(rebuild_targets[start:end])


def _build_target(targets):
    """Build the jar or srcjar files.

    Use -k to keep going when some targets can't be built or build failed.
    Use -j to speed up building.

    Args:
        targets: A list of jar or srcjar files which need to build.
    """
    build_cmd = ['-k', '-j']
    build_cmd.extend(list(targets))
    verbose = True
    if not atest_utils.build(build_cmd, verbose):
        message = ('Build failed!\n{}\nAIDEGen will proceed but dependency '
                   'correctness is not guaranteed if not all targets being '
                   'built successfully.'.format('\n'.join(targets)))
        print('\n{} {}\n'.format(common_util.COLORED_INFO('Warning:'), message))


def _separate_build_targets(build_targets, max_length):
    """Separate the build_targets by limit the command size to max command
    length.

    Args:
        build_targets: A list to be separated.
        max_length: The max number of each build command length.

    Yields:
        The start index and end index of build_targets.
    """
    arg_len = 0
    first_item_index = 0
    for i, item in enumerate(build_targets):
        arg_len = arg_len + len(item) + _BLANK_SIZE
        if arg_len > max_length:
            yield first_item_index, i
            first_item_index = i
            arg_len = len(item) + _BLANK_SIZE
    if first_item_index < len(build_targets):
        yield first_item_index, len(build_targets)