| #!/usr/bin/env python3 |
| |
| # Copyright 2018 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| """A script used to manage Google Maven dependencies for Chromium. |
| |
| For each dependency in `build.gradle`: |
| |
| - Download the library |
| - Download the LICENSE |
| - Generate a README.chromium file |
| - Generate a GN target in BUILD.gn |
| - Generate .info files for AAR libraries |
| - Generate a 'deps' entry in DEPS. |
| """ |
| |
| import argparse |
| import collections |
| import contextlib |
| import fnmatch |
| import logging |
| import os |
| import pathlib |
| import re |
| import shutil |
| import subprocess |
| import sys |
| import tempfile |
| import textwrap |
| import urllib.request |
| import zipfile |
| |
| from typing import Dict |
| |
| # Assume this script is stored under third_party/android_deps/ |
| _CHROMIUM_SRC = os.path.normpath(os.path.join(__file__, '..', '..', '..')) |
| |
| sys.path.insert(1, os.path.join(_CHROMIUM_SRC, 'build/autoroll')) |
| import fetch_util |
| |
| # Default android_deps directory. |
| _PRIMARY_ANDROID_DEPS_DIR = os.path.join(_CHROMIUM_SRC, 'third_party', |
| 'android_deps') |
| |
| # Path to additional_readme_paths.json relative to custom 'android_deps' directory. |
| _ADDITIONAL_README_PATHS = 'additional_readme_paths.json' |
| |
| # Path to Bill of Materials json output by gradle. |
| _BOM_NAME = 'bill_of_materials.json' |
| |
| # Path to BUILD.gn file from custom 'android_deps' directory. |
| _BUILD_GN = 'BUILD.gn' |
| |
| # The word DEPS in case we forget how to spell XD. |
| _DEPS = 'DEPS' |
| |
| # Path to build.gradle file relative to custom 'android_deps' directory. |
| _BUILD_GRADLE = 'build.gradle' |
| |
| # Location of the android_deps libs directory relative to custom 'android_deps' directory. |
| _LIBS_DIR = 'libs' |
| |
| _GN_PATH = os.path.join(_CHROMIUM_SRC, 'third_party', 'depot_tools', 'gn.py') |
| |
| _GRADLEW = os.path.join(_CHROMIUM_SRC, 'third_party', 'android_build_tools', |
| 'gradle_wrapper', 'gradlew') |
| |
| _JAVA_HOME = os.path.join(_CHROMIUM_SRC, 'third_party', 'jdk', 'current') |
| |
| # Git-controlled files needed by, but not updated by this tool. |
| # Relative to _PRIMARY_ANDROID_DEPS_DIR. |
| _PRIMARY_ANDROID_DEPS_FILES = [ |
| 'buildSrc', |
| 'licenses', |
| 'settings.gradle.template', |
| ] |
| |
| # Git-controlled files needed by and updated by this tool. |
| # Relative to args.android_deps_dir. |
| _CUSTOM_ANDROID_DEPS_FILES = [ |
| _BUILD_GN, |
| _ADDITIONAL_README_PATHS, |
| 'subprojects.txt', |
| ] |
| |
| # Dictionary mapping long info file names to shorter ones to avoid paths being |
| # over 200 chars. This must match the dictionary in BuildConfigGenerator.groovy. |
| _REDUCED_ID_LENGTH_MAP = { |
| 'com_google_android_apps_common_testing_accessibility_framework_accessibility_test_framework': |
| 'com_google_android_accessibility_test_framework', |
| } |
| |
| # If this file exists in an aar file then it is appended to LICENSE |
| _THIRD_PARTY_LICENSE_FILENAME = 'third_party_licenses.txt' |
| |
| # Path to the aar.py script used to generate .info files. |
| _AAR_PY = os.path.join(_CHROMIUM_SRC, 'build', 'android', 'gyp', 'aar.py') |
| |
| |
| @contextlib.contextmanager |
| def BuildDir(dirname=None): |
| """Helper function used to manage a build directory. |
| |
| Args: |
| dirname: Optional build directory path. If not provided, a temporary |
| directory will be created and cleaned up on exit. |
| Returns: |
| A python context manager modelling a directory path. The manager |
| removes the directory if necessary on exit. |
| """ |
| delete = False |
| if not dirname: |
| dirname = tempfile.mkdtemp() |
| delete = True |
| try: |
| yield dirname |
| finally: |
| if delete: |
| shutil.rmtree(dirname) |
| |
| |
| def RaiseCommandException(args, returncode, output, error): |
| """Raise an exception whose message describing a command failure. |
| |
| Args: |
| args: shell command-line (as passed to subprocess.call()) |
| returncode: status code. |
| error: standard error output. |
| Raises: |
| a new Exception. |
| """ |
| message = 'Command failed with status {}: {}\n'.format(returncode, args) |
| if output: |
| message += 'Output:-----------------------------------------\n{}\n' \ |
| '------------------------------------------------\n'.format(output) |
| if error: |
| message += 'Error message: ---------------------------------\n{}\n' \ |
| '------------------------------------------------\n'.format(error) |
| raise Exception(message) |
| |
| |
| def RunCommand(args, print_stdout=False, cwd=None): |
| """Run a new shell command. |
| |
| This function runs without printing anything. |
| |
| Args: |
| args: A string or a list of strings for the shell command. |
| Raises: |
| On failure, raise an Exception that contains the command's arguments, |
| return status, and standard output + error merged in a single message. |
| """ |
| logging.debug('Run %s', args) |
| stdout = None if print_stdout else subprocess.PIPE |
| # Explicitly set JAVA_HOME since some bots do not have this already set. |
| env = os.environ.copy() |
| env['JAVA_HOME'] = _JAVA_HOME |
| p = subprocess.Popen(args, stdout=stdout, cwd=cwd, env=env) |
| pout, _ = p.communicate() |
| if p.returncode != 0: |
| RaiseCommandException(args, p.returncode, None, pout) |
| |
| |
| def RunCommandAndGetOutput(args): |
| """Run a new shell command. Return its output. Exception on failure. |
| |
| This function runs without printing anything. |
| |
| Args: |
| args: A string or a list of strings for the shell command. |
| Returns: |
| The command's output. |
| Raises: |
| On failure, raise an Exception that contains the command's arguments, |
| return status, and standard output, and standard error as separate |
| messages. |
| """ |
| logging.debug('Run %s', args) |
| # Explicitly set JAVA_HOME since some bots do not have this already set. |
| env = os.environ.copy() |
| env['JAVA_HOME'] = _JAVA_HOME |
| p = subprocess.Popen(args, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE, |
| env=env) |
| pout, perr = p.communicate() |
| if p.returncode != 0: |
| RaiseCommandException(args, p.returncode, pout, perr) |
| return pout |
| |
| |
| def MakeDirectory(dir_path): |
| """Make directory |dir_path| recursively if necessary.""" |
| if dir_path != '' and not os.path.isdir(dir_path): |
| logging.debug('mkdir [%s]', dir_path) |
| os.makedirs(dir_path) |
| |
| |
| def DeleteDirectory(dir_path): |
| """Recursively delete a directory if it exists.""" |
| if os.path.exists(dir_path): |
| logging.debug('rmdir [%s]', dir_path) |
| shutil.rmtree(dir_path) |
| |
| |
| def Symlink(src_dir, src_paths, dst_dir, dst_paths): |
| for src_path, dst_path in zip(src_paths, dst_paths): |
| abs_src_path = os.path.join(src_dir, src_path) |
| abs_dst_path = os.path.join(dst_dir, dst_path) |
| shutil.rmtree(abs_dst_path, ignore_errors=True) |
| if os.path.exists(abs_dst_path): |
| os.unlink(abs_dst_path) |
| MakeDirectory(os.path.dirname(abs_dst_path)) |
| os.symlink(abs_src_path, abs_dst_path) |
| |
| |
| def Copy(src_dir, src_paths, dst_dir, dst_paths, src_path_must_exist=True): |
| """Copies |src_paths| in |src_dir| to |dst_paths| in |dst_dir|. |
| |
| Args: |
| src_dir: Directory containing |src_paths|. |
| src_paths: Files to copy. |
| dst_dir: Directory containing |dst_paths|. |
| dst_paths: Copy destinations. |
| src_paths_must_exist: If False, do not throw error if the file for one of |
| |src_paths| does not exist. |
| """ |
| assert len(src_paths) == len(dst_paths) |
| |
| missing_files = [] |
| for src_path, dst_path in zip(src_paths, dst_paths): |
| abs_src_path = os.path.join(src_dir, src_path) |
| abs_dst_path = os.path.join(dst_dir, dst_path) |
| if os.path.exists(abs_src_path): |
| CopyFileOrDirectory(abs_src_path, abs_dst_path) |
| elif src_path_must_exist: |
| missing_files.append(src_path) |
| |
| if missing_files: |
| raise Exception('Missing files from {}: {}'.format( |
| src_dir, missing_files)) |
| |
| |
| def CopyFileOrDirectory(src_path, dst_path, ignore_extension=None): |
| """Copy file or directory |src_path| into |dst_path| exactly. |
| |
| Args: |
| src_path: Source path. |
| dst_path: Destination path. |
| ignore_extension: File extension of files not to copy, starting with '.'. If None, all files |
| are copied. |
| """ |
| assert not ignore_extension or ignore_extension[0] == '.' |
| |
| src_path = os.path.normpath(src_path) |
| dst_path = os.path.normpath(dst_path) |
| logging.debug('copy [%s -> %s]', src_path, dst_path) |
| MakeDirectory(os.path.dirname(dst_path)) |
| if os.path.isdir(src_path): |
| # Copy directory recursively. |
| DeleteDirectory(dst_path) |
| ignore = None |
| if ignore_extension: |
| ignore = shutil.ignore_patterns('*' + ignore_extension) |
| shutil.copytree(src_path, dst_path, ignore=ignore) |
| subprocess.run(['chmod', '-R', '+w', dst_path]) |
| elif not ignore_extension or not re.match(r'.*\.' + ignore_extension[1:], |
| src_path): |
| # cipd/gclient extract files as read only, allow writing before trying |
| # to override. |
| if os.path.exists(dst_path): |
| subprocess.run(['chmod', '+w', dst_path]) |
| shutil.copy(src_path, dst_path) |
| # In case src_path was also from cipd, +w after copying too. |
| subprocess.run(['chmod', '+w', dst_path]) |
| |
| |
| def ReadFile(file_path): |
| """Read a file, return its content.""" |
| with open(file_path) as f: |
| return f.read() |
| |
| |
| def ReadFileAsLines(file_path): |
| """Read a file as a series of lines.""" |
| with open(file_path) as f: |
| return f.readlines() |
| |
| |
| def WriteFile(file_path, file_data): |
| """Write a file.""" |
| if isinstance(file_data, str): |
| file_data = file_data.encode('utf8') |
| MakeDirectory(os.path.dirname(file_path)) |
| with open(file_path, 'wb') as f: |
| f.write(file_data) |
| |
| |
| def FindInDirectory(directory, filename_filter): |
| """Find all files in a directory that matches a given filename filter.""" |
| files = [] |
| for root, _dirnames, filenames in os.walk(directory): |
| matched_files = fnmatch.filter(filenames, filename_filter) |
| files.extend((os.path.join(root, f) for f in matched_files)) |
| return files |
| |
| |
| # Named tuple describing a CIPD package. |
| # - path: Path to cipd.yaml file. |
| # - name: cipd package name. |
| # - tag: cipd tag. |
| CipdPackageInfo = collections.namedtuple('CipdPackageInfo', |
| ['path', 'name', 'tag']) |
| |
| # Regular expressions used to extract useful info from cipd.yaml files |
| # generated by Gradle. See BuildConfigGenerator.groovy:makeCipdYaml() |
| _RE_CIPD_CREATE = re.compile(r'cipd create --pkg-def cipd.yaml -tag (\S*)') |
| _RE_CIPD_PACKAGE = re.compile(r'package: (\S*)') |
| |
| |
| def _ParseSubprojects(subproject_path): |
| """Parses listing of subproject build.gradle files. Returns list of paths.""" |
| if not os.path.exists(subproject_path): |
| return {} |
| |
| subprojects = {} |
| for subproject in open(subproject_path): |
| subproject = subproject.strip() |
| if subproject and not subproject.startswith('#'): |
| path, name = subproject.split(':') |
| subprojects[name] = path |
| return subprojects |
| |
| |
| def _GenerateSettingsGradle(subproject_dirs: Dict[str, str], |
| settings_template_path, settings_out_path): |
| """Generates settings file by replacing "{{subproject_dirs}}" string in template. |
| |
| Args: |
| subproject_dirs: List of subproject directories to substitute into template. |
| settings_template_path: Path of template file to substitute into. |
| settings_out_path: Path of output settings.gradle file. |
| """ |
| with open(settings_template_path) as f: |
| template_content = f.read() |
| |
| subproject_dirs_str = '' |
| if subproject_dirs: |
| mappings = [] |
| for name, path in subproject_dirs.items(): |
| mappings.append(f'{name}: \'{path}\'') |
| subproject_dirs_str = ', '.join(mappings) |
| |
| template_content = template_content.replace('{{subproject_dirs}}', |
| subproject_dirs_str) |
| with open(settings_out_path, 'w') as f: |
| f.write(template_content) |
| |
| |
| def _InitSubprojects(android_deps_dir, build_android_deps_dir, |
| using_build_dir: bool): |
| subprojects = _ParseSubprojects( |
| os.path.join(android_deps_dir, 'subprojects.txt')) |
| subdirs = {name: f'subproject_{name}' for name in subprojects} |
| for name, original_path in subprojects.items(): |
| subdir = subdirs[name] |
| build_gradle = os.path.join(subdir, _BUILD_GRADLE) |
| src_path = pathlib.Path(android_deps_dir) / original_path |
| data = src_path.read_text() |
| if '// <ANDROIDX_REPO>' in data: |
| version = fetch_util.get_current_androidx_version() |
| repo_url = fetch_util.make_androidx_maven_url(version) |
| data = data.replace('// <ANDROIDX_REPO>', |
| f'maven {{ url "{repo_url}" }}') |
| dst_path = pathlib.Path(build_android_deps_dir) / build_gradle |
| dst_path.parent.mkdir(exist_ok=using_build_dir) |
| dst_path.write_text(data) |
| |
| _GenerateSettingsGradle( |
| subdirs, |
| os.path.join(_PRIMARY_ANDROID_DEPS_DIR, 'settings.gradle.template'), |
| os.path.join(build_android_deps_dir, 'settings.gradle')) |
| |
| def _BuildGradleCmd(build_android_deps_dir, task): |
| return [ |
| _GRADLEW, '-p', build_android_deps_dir, '--stacktrace', |
| '--warning-mode', 'all', task |
| ] |
| |
| |
| def _ReduceNameLength(path_str): |
| """Returns a shorter path string if needed. |
| |
| Args: |
| path_str: A String representing the path. |
| Returns: |
| A String (possibly shortened) of that path. |
| """ |
| return _REDUCED_ID_LENGTH_MAP.get(path_str, path_str) |
| |
| |
| def GetCipdPackageInfo(cipd_yaml_path): |
| """Returns the CIPD package name corresponding to a given cipd.yaml file. |
| |
| Args: |
| cipd_yaml_path: Path of input cipd.yaml file. |
| Returns: |
| A (package_name, package_tag) tuple. |
| Raises: |
| Exception if the file could not be read. |
| """ |
| package_name = None |
| package_tag = None |
| for line in ReadFileAsLines(cipd_yaml_path): |
| m = _RE_CIPD_PACKAGE.match(line) |
| if m: |
| package_name = m.group(1) |
| |
| m = _RE_CIPD_CREATE.search(line) |
| if m: |
| package_tag = m.group(1) |
| |
| if not package_name or not package_tag: |
| raise Exception('Invalid cipd.yaml format: ' + cipd_yaml_path) |
| |
| return (package_name, package_tag) |
| |
| |
| def ParseDeps(root_dir, libs_dir): |
| """Parse an android_deps/libs and retrieve package information. |
| |
| Args: |
| root_dir: Path to a root Chromium or build directory. |
| Returns: |
| A directory mapping package names to tuples of |
| (cipd_yaml_file, package_name, package_tag), where |cipd_yaml_file| |
| is the path to the cipd.yaml file, related to |libs_dir|, |
| and |package_name| and |package_tag| are the extracted from it. |
| """ |
| result = {} |
| root_dir = os.path.abspath(root_dir) |
| libs_dir = os.path.abspath(os.path.join(root_dir, libs_dir)) |
| # TODO(mheikal): do not use cipd.yaml for this since it is not useful for |
| # subprojects. Change to read from a README.chromium |
| for cipd_file in FindInDirectory(libs_dir, 'cipd.yaml'): |
| pkg_name, pkg_tag = GetCipdPackageInfo(cipd_file) |
| cipd_path = os.path.dirname(cipd_file) |
| cipd_path = cipd_path[len(root_dir) + 1:] |
| result[pkg_name] = CipdPackageInfo(cipd_path, pkg_name, pkg_tag) |
| |
| return result |
| |
| |
| def PrintPackageList(packages, list_name): |
| """Print a list of packages to standard output. |
| |
| Args: |
| packages: list of package names. |
| list_name: a simple word describing the package list (e.g. 'new') |
| """ |
| print(' {} {} packages:'.format(len(packages), list_name)) |
| print('\n'.join(' - ' + p for p in packages)) |
| |
| |
| def _DownloadOverrides(overrides, build_libs_dir): |
| for spec in overrides: |
| subpath, url = spec.split(':', 1) |
| target_path = os.path.join(build_libs_dir, subpath) |
| if not os.path.isfile(target_path): |
| found_files = 'Found instead:\n' + '\n'.join( |
| FindInDirectory(os.path.dirname(target_path), '*')) |
| raise Exception( |
| f'Override path does not exist: {target_path}\n{found_files}') |
| logging.info('Fetching override for %s', target_path) |
| with urllib.request.urlopen(url) as response: |
| with open(target_path, 'wb') as f: |
| shutil.copyfileobj(response, f) |
| |
| |
| def _CreateAarInfos(aar_files): |
| jobs = [] |
| |
| for aar_file in aar_files: |
| aar_dirname = os.path.dirname(aar_file) |
| aar_info_name = _ReduceNameLength( |
| os.path.basename(aar_dirname)) + '.info' |
| aar_info_path = os.path.join(aar_dirname, aar_info_name) |
| |
| logging.debug('- %s', aar_info_name) |
| cmd = [_AAR_PY, 'list', aar_file, '--output', aar_info_path] |
| |
| if aar_info_name == 'com_google_android_material_material.info': |
| # Keep in sync with copy in BuildConfigGenerator.groovy. |
| resource_exclusion_glbos = [ |
| 'res/layout*/*calendar*', |
| 'res/layout*/*chip_input*', |
| 'res/layout*/*clock*', |
| 'res/layout*/*picker*', |
| 'res/layout*/*time*', |
| ] |
| cmd += [ |
| '--resource-exclusion-globs', |
| repr(resource_exclusion_glbos).replace("'", '"') |
| ] |
| proc = subprocess.Popen(cmd) |
| jobs.append((cmd, proc)) |
| |
| for cmd, proc in jobs: |
| if proc.wait(): |
| raise Exception('Command Failed: {}\n'.format(' '.join(cmd))) |
| |
| |
| def _FixArchiveNames(android_deps_dir): |
| # Make sure the .aar / .jar has the filename according to the cipd.yaml |
| # file. 3pp bot does this transformation for us, but it's needed for |
| # --local and for the autorolled / androidx packages. |
| src_libs_dir = os.path.join(android_deps_dir, _LIBS_DIR) |
| # Match .aar and .jar |
| for src_path in FindInDirectory(src_libs_dir, '*.?ar'): |
| dirname = os.path.dirname(src_path) |
| yaml_path = os.path.join(dirname, 'cipd.yaml') |
| data = pathlib.Path(yaml_path).read_text('utf-8') |
| new_name = re.search(r'- file: (.*)', data).group(1) |
| dst_path = os.path.join(dirname, new_name) |
| logging.debug('mv [%s -> %s]', src_path, dst_path) |
| shutil.move(src_path, dst_path) |
| |
| |
| def _CopyJarFilesToCipd(android_deps_dir): |
| src_libs_dir = os.path.join(android_deps_dir, _LIBS_DIR) |
| # Match .aar and .jar |
| for src_path in FindInDirectory(src_libs_dir, '*.?ar'): |
| dst_path = os.path.join(android_deps_dir, 'cipd', _LIBS_DIR, |
| os.path.relpath(src_path, src_libs_dir)) |
| logging.debug('mv [%s -> %s]', src_path, dst_path) |
| if os.path.exists(dst_path): |
| os.unlink(dst_path) |
| os.makedirs(os.path.dirname(dst_path), exist_ok=True) |
| shutil.move(src_path, dst_path) |
| |
| |
| def main(): |
| parser = argparse.ArgumentParser( |
| description=__doc__, |
| formatter_class=argparse.RawDescriptionHelpFormatter) |
| parser.add_argument( |
| '--android-deps-dir', |
| help='Path to directory containing build.gradle from chromium-dir.', |
| default=_PRIMARY_ANDROID_DEPS_DIR) |
| parser.add_argument( |
| '--output-subdir', |
| help='Path to subdirectory under --android-deps-dir to output to ' |
| 'instead.') |
| parser.add_argument( |
| '--build-dir', |
| help='Path to build directory (default is temporary directory).') |
| parser.add_argument('--ignore-licenses', |
| help='Ignores licenses for these deps.', |
| action='store_true') |
| parser.add_argument('--override-artifact', |
| action='append', |
| help='lib_subpath:url of .aar / .jar to override.') |
| parser.add_argument('--local', |
| help='Move .jar and .aar files to cipd/ directory ' |
| 'after running (3pp bot requires this to not ' |
| 'happen)', |
| action='store_true') |
| parser.add_argument('-v', |
| '--verbose', |
| dest='verbose_count', |
| default=0, |
| action='count', |
| help='Verbose level (multiple times for more)') |
| args = parser.parse_args() |
| |
| logging.basicConfig( |
| level=logging.WARNING - 10 * args.verbose_count, |
| format='%(levelname).1s %(relativeCreated)6d %(message)s') |
| debug = args.verbose_count >= 2 |
| |
| if 'SWARMING_TASK_ID' not in os.environ and not (args.local |
| or args.output_subdir): |
| logging.warning( |
| 'Detected not running on a bot. You probably want to use --local') |
| |
| if not os.path.isfile(os.path.join(args.android_deps_dir, _BUILD_GRADLE)): |
| raise Exception('--android-deps-dir {} does not contain {}.'.format( |
| args.android_deps_dir, _BUILD_GRADLE)) |
| is_primary_android_deps = os.path.samefile(args.android_deps_dir, |
| _PRIMARY_ANDROID_DEPS_DIR) |
| android_deps_relpath = os.path.relpath(args.android_deps_dir, |
| _CHROMIUM_SRC) |
| output_android_deps_dir = args.android_deps_dir |
| if args.output_subdir: |
| output_android_deps_dir = os.path.join(args.android_deps_dir, |
| args.output_subdir) |
| |
| with BuildDir(args.build_dir) as build_dir: |
| build_android_deps_dir = os.path.join(build_dir, android_deps_relpath) |
| |
| logging.info('Using build directory: %s', build_dir) |
| if args.build_dir: |
| # Always use the latest files from the repo when debugging. |
| Symlink(_PRIMARY_ANDROID_DEPS_DIR, _PRIMARY_ANDROID_DEPS_FILES, |
| build_android_deps_dir, _PRIMARY_ANDROID_DEPS_FILES) |
| else: |
| Copy(_PRIMARY_ANDROID_DEPS_DIR, _PRIMARY_ANDROID_DEPS_FILES, |
| build_android_deps_dir, _PRIMARY_ANDROID_DEPS_FILES) |
| Copy(args.android_deps_dir, [_BUILD_GRADLE], build_android_deps_dir, |
| [_BUILD_GRADLE]) |
| Copy(args.android_deps_dir, |
| _CUSTOM_ANDROID_DEPS_FILES, |
| build_android_deps_dir, |
| _CUSTOM_ANDROID_DEPS_FILES, |
| src_path_must_exist=is_primary_android_deps) |
| |
| Copy(_CHROMIUM_SRC, [_DEPS], build_dir, [_DEPS]) |
| |
| _InitSubprojects(args.android_deps_dir, build_android_deps_dir, |
| bool(args.build_dir)) |
| |
| logging.info('Running Gradle.') |
| |
| # This gradle command generates the new DEPS and BUILD.gn files, it can |
| # also handle special cases. |
| # Edit BuildConfigGenerator.groovy#addSpecialTreatment for such cases. |
| gradle_cmd = _BuildGradleCmd(build_android_deps_dir, 'setupRepository') |
| if debug: |
| gradle_cmd.append('--debug') |
| if args.ignore_licenses: |
| gradle_cmd.append('-PskipLicenses=true') |
| |
| RunCommand(gradle_cmd, print_stdout=True) |
| |
| logging.info('# Reformat %s.', |
| os.path.join(args.android_deps_dir, _BUILD_GN)) |
| gn_path = os.path.relpath(_GN_PATH, _CHROMIUM_SRC) |
| |
| gn_input = os.path.join(build_android_deps_dir, _BUILD_GN) |
| gn_args = [gn_path, 'format', gn_input] |
| try: |
| RunCommand(gn_args, print_stdout=debug, cwd=_CHROMIUM_SRC) |
| except Exception: |
| if os.path.exists(gn_input): |
| shutil.copyfile(gn_input, '/tmp/gn-format-input') |
| logging.warning('Saved GN input to /tmp/gn-format-input') |
| raise |
| |
| build_libs_dir = os.path.join(build_android_deps_dir, _LIBS_DIR) |
| if args.override_artifact: |
| _DownloadOverrides(args.override_artifact, build_libs_dir) |
| aar_files = FindInDirectory(build_libs_dir, '*.aar') |
| |
| logging.info('# Generate Android .aar info files.') |
| _CreateAarInfos(aar_files) |
| |
| if not args.ignore_licenses: |
| logging.info('# Looking for nested license files.') |
| for aar_file in aar_files: |
| # Play Services .aar files have embedded licenses. |
| with zipfile.ZipFile(aar_file) as z: |
| if _THIRD_PARTY_LICENSE_FILENAME in z.namelist(): |
| aar_dirname = os.path.dirname(aar_file) |
| license_path = os.path.join(aar_dirname, 'LICENSE') |
| # Make sure to append as we don't want to lose the |
| # existing license. |
| with open(license_path, 'ab') as f: |
| f.write(z.read(_THIRD_PARTY_LICENSE_FILENAME)) |
| |
| logging.info('# Compare CIPD packages.') |
| existing_packages = ParseDeps(output_android_deps_dir, _LIBS_DIR) |
| build_packages = ParseDeps(build_android_deps_dir, _LIBS_DIR) |
| |
| deleted_packages = [] |
| updated_packages = [] |
| for pkg in sorted(existing_packages): |
| if pkg not in build_packages: |
| deleted_packages.append(pkg) |
| else: |
| existing_info = existing_packages[pkg] |
| build_info = build_packages[pkg] |
| if existing_info.tag != build_info.tag: |
| updated_packages.append(pkg) |
| |
| new_packages = sorted(set(build_packages) - set(existing_packages)) |
| |
| # Copy updated DEPS and BUILD.gn to build directory. |
| Copy(build_android_deps_dir, |
| _CUSTOM_ANDROID_DEPS_FILES, |
| output_android_deps_dir, |
| _CUSTOM_ANDROID_DEPS_FILES, |
| src_path_must_exist=is_primary_android_deps) |
| |
| # Auto-rollers adjust DEPS for androidx & autorolled. |
| if is_primary_android_deps: |
| Copy(build_dir, [_DEPS], _CHROMIUM_SRC, [_DEPS]) |
| |
| # Not all projects (eg: the primary project) output a bill of materials. |
| # Thus only copy if it exists. |
| Copy(build_android_deps_dir, [_BOM_NAME], |
| output_android_deps_dir, [_BOM_NAME], |
| src_path_must_exist=False) |
| |
| # Delete obsolete or updated package directories. |
| # TODO(mheikal): also delete directories that do not have a cipd.yaml |
| # file, there shouldn't be any of those under libs/ |
| for pkg in existing_packages.values(): |
| pkg_path = os.path.join(output_android_deps_dir, pkg.path) |
| DeleteDirectory(pkg_path) |
| |
| # Copy new and updated packages from build directory. |
| for pkg in build_packages.values(): |
| pkg_path = pkg.path |
| dst_pkg_path = os.path.join(output_android_deps_dir, pkg_path) |
| src_pkg_path = os.path.join(build_android_deps_dir, pkg_path) |
| CopyFileOrDirectory(src_pkg_path, |
| dst_pkg_path, |
| ignore_extension=".tmp") |
| |
| _FixArchiveNames(output_android_deps_dir) |
| if args.local and not args.output_subdir: |
| _CopyJarFilesToCipd(args.android_deps_dir) |
| |
| # Useful for printing timestamp. |
| logging.info('All Done.') |
| |
| if new_packages: |
| PrintPackageList(new_packages, 'new') |
| if updated_packages: |
| PrintPackageList(updated_packages, 'updated') |
| if deleted_packages: |
| PrintPackageList(deleted_packages, 'deleted') |
| |
| |
| if __name__ == "__main__": |
| main() |
