build/android/list_java_targets.py

#!/usr/bin/env python3
# Copyright 2020 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

# Lint as: python3
"""Prints out available java targets.

Examples:
# List GN target for bundles:
build/android/list_java_targets.py -C out/Default --type android_app_bundle \
--gn-labels

# List all android targets with types:
build/android/list_java_targets.py -C out/Default --print-types

# Build all apk targets:
build/android/list_java_targets.py -C out/Default --type android_apk | xargs \
autoninja -C out/Default

# Show how many of each target type exist:
build/android/list_java_targets.py -C out/Default --stats

"""

import argparse
import collections
import glob
import json
import logging
import os
import shlex
import subprocess
import sys

_SRC_ROOT = os.path.normpath(
    os.path.join(os.path.dirname(__file__), '..', '..')
)
sys.path.append(os.path.join(_SRC_ROOT, 'build'))
import gn_helpers

sys.path.append(os.path.join(_SRC_ROOT, 'build', 'android'))
from pylib import constants

_VALID_TYPES = (
    'android_apk',
    'android_app_bundle',
    'android_app_bundle_module',
    'android_assets',
    'android_resources',
    'dist_aar',
    'dist_jar',
    'group',
    'java_annotation_processor',
    'java_binary',
    'java_library',
    'robolectric_binary',
    'system_java_library',
)


def _compile(output_dir, args, quiet=False):
    cmd = gn_helpers.CreateBuildCommand(output_dir) + args
    logging.info('Running: %s', shlex.join(cmd))
    if quiet:
        subprocess.run(cmd, check=True, capture_output=True)
    else:
        subprocess.run(cmd, check=True, stdout=sys.stderr)


def _query_for_targets(output_dir):
    # Query ninja rather than GN since it's faster.
    cmd = [
        os.path.join(_SRC_ROOT, 'third_party', 'siso', 'cipd', 'siso'),
        'query',
        'targets',
        '-C',
        output_dir,
    ]
    logging.info('Running: %r', cmd)
    try:
        query_output = subprocess.run(
            cmd, check=True, capture_output=True, encoding='ascii'
        ).stdout
    except subprocess.CalledProcessError as e:
        sys.stderr.write('Command output:\n' + e.stdout + e.stderr)
        raise

    # Dict of target name -> has_build_config
    ret = {}
    # java_prebuilt() targets do not write build_config files, so look for
    # __assetres as well. Targets like android_assets() will not appear at all
    # (oh well).
    SUFFIX1 = '__build_config_crbug_908819'
    SUFFIX_LEN1 = len(SUFFIX1)
    SUFFIX2 = '__assetres'
    SUFFIX_LEN2 = len(SUFFIX2)
    for line in query_output.splitlines():
        ninja_target = line.rsplit(':', 1)[0]
        # Ignore root aliases by ensuring a : exists.
        if ':' in ninja_target:
            if ninja_target.endswith(SUFFIX1):
                ret[f'//{ninja_target[:-SUFFIX_LEN1]}'] = True
            elif ninja_target.endswith(SUFFIX2):
                ret.setdefault(f'//{ninja_target[:-SUFFIX_LEN2]}', False)
    return ret


def _query_json(*, json_dict: dict, query: str, target: str):
    """Traverses through the json dictionary according to the query.

    If at any point a key does not exist, return the empty string, but raise an
    error if a key exists but is the wrong type.

    This is roughly equivalent to returning
    json_dict[queries[0]]?[queries[1]]?...[queries[N]]? where the ? means that if
    the key doesn't exist, the empty string is returned.

    Example:
    Given json_dict = {'a': {'b': 'c'}}
    - If queries = ['a', 'b']
      Return: 'c'
    - If queries = ['a', 'd']
      Return ''
    - If queries = ['x']
      Return ''
    - If queries = ['a', 'b', 'x']
      Raise an error since json_dict['a']['b'] is the string 'c' instead of an
      expected dict that can be indexed into.

    Returns the final result after exhausting all the queries.
    """
    queries = query.split('.')
    value = json_dict
    try:
        for key in queries:
            value = value.get(key)
            if value is None:
                return ''
    except AttributeError as e:
        raise Exception(
            f'Failed when attempting to get {queries} from {target}'
        ) from e
    return value


class _TargetEntry:
    def __init__(self, gn_target, has_build_config):
        assert gn_target.startswith('//'), f'{gn_target} does not start with //'
        assert ':' in gn_target, f'Non-root {gn_target} required'
        self.gn_target = gn_target
        self.has_build_config = has_build_config
        self._combined_config = None
        self._params_json = None

    @property
    def ninja_target(self):
        return self.gn_target[2:]

    @property
    def ninja_build_config_target(self):
        assert self.has_build_config, 'No build config for ' + self.gn_target
        return self.ninja_target + '__build_config_crbug_908819'

    @property
    def build_config_path(self):
        """Returns the filepath of the project's .build_config.json."""
        assert self.has_build_config, 'No build config for ' + self.gn_target
        return self.params_path.replace('.params.json', '.build_config.json')

    @property
    def params_path(self):
        """Returns the filepath of the project's .params.json."""
        ninja_target = self.ninja_target
        # Support targets at the root level. e.g. //:foo
        if ninja_target[0] == ':':
            ninja_target = ninja_target[1:]
        subpath = ninja_target.replace(':', os.path.sep) + '.params.json'
        return os.path.relpath(
            os.path.join(constants.GetOutDirectory(), 'gen', subpath)
        )

    def params_values(self):
        if not self._params_json:
            with open(self.params_path) as f:
                self._params_json = json.load(f)
        return self._params_json

    def combined_config_values(self):
        """Union of .params.json and *.build_config.json"""
        if not self._combined_config:
            config = dict(self.params_values())
            if self.has_build_config:
                pattern = self.build_config_path.replace(
                    '.build_config.json', '*.build_config.json'
                )
                for p in glob.glob(pattern):
                    with open(p) as f:
                        config.update(json.load(f))
            self._combined_config = config
        return self._combined_config

    def get_type(self):
        """Returns the target type from its .build_config.json."""
        return self.params_values()['type']

    def proguard_enabled(self):
        """Returns whether proguard runs for this target."""
        # Modules set proguard_enabled, but the proguarding happens only once at the
        # bundle level.
        if self.get_type() == 'android_app_bundle_module':
            return False
        return self.params_values().get('proguard_enabled', False)


def main():
    parser = argparse.ArgumentParser(
        description=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument(
        '-C',
        '--output-directory',
        help='If outdir is not provided, will attempt to guess.',
    )
    parser.add_argument(
        '--gn-labels',
        action='store_true',
        help='Print GN labels rather than ninja targets',
    )
    parser.add_argument(
        '--omit-targets',
        action='store_true',
        help='Do not print the target / gn label',
    )
    parser.add_argument(
        '--nested',
        action='store_true',
        help='Do not convert nested targets to their top-level equivalents. '
        'E.g. Without this, foo_test__apk -> foo_test',
    )
    parser.add_argument(
        '--print-types', action='store_true', help='Print type of each target'
    )
    parser.add_argument(
        '--print-build-config-paths',
        action='store_true',
        help='Print path to the .build_config.json of each target',
    )
    parser.add_argument(
        '--print-params-paths',
        action='store_true',
        help='Print path to the .params.json of each target',
    )
    parser.add_argument(
        '--build',
        action='store_true',
        help='Build all .build_config.json files.',
    )
    parser.add_argument(
        '--type',
        action='append',
        help='Restrict to targets of given type',
        choices=_VALID_TYPES,
    )
    parser.add_argument(
        '--stats', action='store_true', help='Print counts of each target type.'
    )
    parser.add_argument(
        '--proguard-enabled',
        action='store_true',
        help='Restrict to targets that have proguard enabled.',
    )
    parser.add_argument(
        '--query',
        help='A dot separated string specifying a query for a '
        'build config json value of each target. Example: Use '
        '--query unprocessed_jar_path to show a list '
        'of all targets that have a non-empty '
        '"unprocessed_jar_path" value in that dict.',
    )
    parser.add_argument('-v', '--verbose', default=0, action='count')
    parser.add_argument('-q', '--quiet', default=0, action='count')
    args = parser.parse_args()

    args.build |= bool(
        args.type
        or args.proguard_enabled
        or args.print_types
        or args.stats
        or args.query
    )

    logging.basicConfig(
        level=logging.WARNING + 10 * (args.quiet - args.verbose),
        format='%(levelname).1s %(relativeCreated)6d %(message)s',
    )

    if args.output_directory:
        constants.SetOutputDirectory(args.output_directory)
    constants.CheckOutputDirectory()
    output_dir = constants.GetOutDirectory()

    if args.build:
        _compile(output_dir, ['build.ninja'])

    # Query ninja for all __build_config_crbug_908819 targets.
    # TODO(agrieve): java_group, android_assets, and android_resources do not
    # write .build_config.json files, and so will not show up by this query.
    # If we ever need them to, use "gn gen" into a temp dir, and set an extra
    # gn arg that causes all write_build_config() template to print all targets.
    result = _query_for_targets(output_dir)
    entries = [_TargetEntry(t, v) for t, v in sorted(result.items())]
    entries = [e for e in entries if os.path.exists(e.params_path)]

    if not entries:
        logging.warning('No targets found. Run with --build')
        sys.exit(1)

    if args.build:
        targets = [
            e.ninja_build_config_target for e in entries if e.has_build_config
        ]
        logging.warning('Building %d .build_config.json files...', len(targets))
        _compile(output_dir, targets, quiet=args.quiet)

    if args.type:
        if set(args.type) & {'android_resources', 'android_assets', 'group'}:
            logging.warning('Cannot filter by this type. See TODO.')
            sys.exit(1)
        entries = [e for e in entries if e.get_type() in args.type]

    if args.proguard_enabled:
        entries = [e for e in entries if e.proguard_enabled()]

    if args.stats:
        counts = collections.Counter(e.get_type() for e in entries)
        for entry_type, count in sorted(counts.items()):
            print(f'{entry_type}: {count}')
    else:
        for e in entries:
            if args.omit_targets:
                target_part = ''
            else:
                if args.gn_labels:
                    target_part = e.gn_target
                else:
                    target_part = e.ninja_target

                # Convert to top-level target
                if not args.nested:
                    target_part = target_part.replace('__test_apk', '').replace(
                        '__apk', ''
                    )

            type_part = ''
            if args.print_types:
                type_part = e.get_type()
            elif args.print_build_config_paths:
                type_part = e.build_config_path if e.has_build_config else 'N/A'
            elif args.print_params_paths:
                type_part = e.params_path
            elif args.query:
                type_part = _query_json(
                    json_dict=e.combined_config_values(),
                    query=args.query,
                    target=e.gn_target,
                )
                if not type_part:
                    continue

            if target_part and type_part:
                print(f'{target_part}: {type_part}')
            elif target_part or type_part:
                print(target_part or type_part)


if __name__ == '__main__':
    main()