| #!/usr/bin/env python3 | |
| # Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file | |
| # for details. All rights reserved. Use of this source code is governed by a | |
| # BSD-style license that can be found in the LICENSE file. | |
| import argparse | |
| import datetime | |
| import json | |
| import os.path | |
| import re | |
| import shutil | |
| import stat | |
| import subprocess | |
| import sys | |
| import tempfile | |
| import urllib.request | |
| import xml.etree.ElementTree | |
| import zipfile | |
| import git_utils | |
| import utils | |
| R8_DEV_BRANCH = '9.6' | |
| R8_VERSION_FILE = os.path.join('src', 'main', 'java', 'com', 'android', 'tools', | |
| 'r8', 'Version.java') | |
| THIS_FILE_RELATIVE = os.path.join('tools', 'r8_release.py') | |
| GMAVEN_PUBLISHER = '/google/bin/releases/android-devtools/gmaven/publisher/gmaven-publisher' | |
| DESUGAR_JDK_LIBS = 'desugar_jdk_libs' | |
| DESUGAR_JDK_LIBS_CONFIGURATION = DESUGAR_JDK_LIBS + '_configuration' | |
| ANDROID_TOOLS_PACKAGE = 'com.android.tools' | |
| GITHUB_DESUGAR_JDK_LIBS = 'https://github.com/google/desugar_jdk_libs' | |
| def install_gerrit_change_id_hook(checkout_dir): | |
| with utils.ChangedWorkingDirectory(checkout_dir): | |
| # Fancy way of getting the string ".git". | |
| git_dir = subprocess.check_output(['git', 'rev-parse', '--git-dir' | |
| ]).decode('utf-8').strip() | |
| commit_msg_hooks = '%s/hooks/commit-msg' % git_dir | |
| if not os.path.exists(os.path.dirname(commit_msg_hooks)): | |
| os.mkdir(os.path.dirname(commit_msg_hooks)) | |
| # Install commit hook to generate Gerrit 'Change-Id:'. | |
| urllib.request.urlretrieve( | |
| 'https://gerrit-review.googlesource.com/tools/hooks/commit-msg', | |
| commit_msg_hooks) | |
| st = os.stat(commit_msg_hooks) | |
| os.chmod(commit_msg_hooks, | |
| st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH) | |
| def checkout_r8(temp, branch): | |
| subprocess.check_call(['git', 'clone', utils.REPO_SOURCE, temp]) | |
| with utils.ChangedWorkingDirectory(temp): | |
| subprocess.check_call([ | |
| 'git', 'new-branch', '--upstream', | |
| 'origin/%s' % branch, 'dev-release' | |
| ]) | |
| install_gerrit_change_id_hook(temp) | |
| return temp | |
| def prepare_release(args): | |
| if args.version: | |
| print("Cannot manually specify version when making a dev release.") | |
| sys.exit(1) | |
| def make_release(args): | |
| commithash = args.dev_release | |
| with utils.TempDir() as temp: | |
| with utils.ChangedWorkingDirectory(checkout_r8(temp, | |
| R8_DEV_BRANCH)): | |
| # Compute the current and new version on the branch. | |
| result = None | |
| use_alpha = utils.check_basic_semver_version( | |
| R8_DEV_BRANCH, | |
| ", current release branch version should be x.y", | |
| components=2).larger_than( | |
| utils.SemanticVersion(9, 5, None, None)) | |
| for line in open(R8_VERSION_FILE, 'r'): | |
| if use_alpha: | |
| result = re.match( | |
| r'.*LABEL = "%s\.0-alpha(\d+)";' % R8_DEV_BRANCH, | |
| line) | |
| else: | |
| result = re.match( | |
| r'.*LABEL = "%s\.(\d+)\-dev";' % R8_DEV_BRANCH, | |
| line) | |
| if result: | |
| break | |
| if not result or not result.group(1): | |
| expected_label = ('%s.0-alpha(\\d+)' | |
| if use_alpha else '%s(\\d+)-dev') | |
| print('Failed to find version label matching %s' % | |
| (expected_label % R8_DEV_BRANCH)) | |
| sys.exit(1) | |
| try: | |
| pre_version = int(result.group(1)) | |
| except ValueError: | |
| print('Failed to convert version to integer: %s' % | |
| result.group(1)) | |
| if use_alpha: | |
| old_version = '%s.0-alpha%02d' % (R8_DEV_BRANCH, | |
| pre_version) | |
| version = '%s.0-alpha%02d' % (R8_DEV_BRANCH, | |
| pre_version + 1) | |
| else: | |
| old_version = '%s.%s-dev' % (R8_DEV_BRANCH, pre_version) | |
| version = '%s.%s-dev' % (R8_DEV_BRANCH, pre_version + 1) | |
| # Verify that the merge point from main is not empty. | |
| merge_diff_output = subprocess.check_output( | |
| ['git', 'diff', 'HEAD..%s' % commithash]).decode('utf-8') | |
| other_diff = version_change_diff(merge_diff_output, old_version, | |
| "main") | |
| if not other_diff: | |
| print('Merge point from main (%s)' % commithash, \ | |
| 'is the same as exiting release (%s).' % old_version) | |
| sys.exit(1) | |
| if args.dev_pre_cherry_pick: | |
| for pre_commit in args.dev_pre_cherry_pick: | |
| subprocess.check_call( | |
| ['git', 'cherry-pick', '--no-edit', pre_commit]) | |
| # Merge the desired commit from main on to the branch. | |
| subprocess.check_call( | |
| ['git', 'merge', '--no-ff', '--no-edit', commithash]) | |
| # Rewrite the version, commit and validate. | |
| sed(old_version, version, R8_VERSION_FILE) | |
| git_utils.git_commit(git_utils.version_commit_message(version)) | |
| version_diff_output = subprocess.check_output( | |
| ['git', 'diff', '%s..HEAD' % commithash]).decode('utf-8') | |
| validate_version_change_diff(version_diff_output, "main", | |
| version) | |
| cmd = ['git', 'cl', 'upload', '--no-squash', '--bypass-hooks'] | |
| git_utils.git_cl_append_reviewers(cmd, args.reviewer, | |
| args.send_mail) | |
| maybe_check_call(args, cmd) | |
| if args.dry_run: | |
| input( | |
| 'DryRun: check %s for content of version %s [enter to continue]:' | |
| % (temp, version)) | |
| return "%s dev version %s from hash %s for review" % ( | |
| 'DryRun: omitted upload of' if args.dry_run else 'Uploaded', | |
| version, commithash) | |
| return make_release | |
| version_commit_message = git_utils.version_commit_message | |
| def version_change_diff(diff, old_version, new_version): | |
| invalid_line = None | |
| for line in str(diff).splitlines(): | |
| if line.startswith('- ') and \ | |
| line != '- public static final String LABEL = "%s";' % old_version: | |
| invalid_line = line | |
| elif line.startswith('+ ') and \ | |
| line != '+ public static final String LABEL = "%s";' % new_version: | |
| invalid_line = line | |
| return invalid_line | |
| def validate_version_change_diff(version_diff_output, old_version, new_version): | |
| invalid = version_change_diff(version_diff_output, old_version, new_version) | |
| if invalid: | |
| print("Unexpected diff:") | |
| print("=" * 80) | |
| print(version_diff_output) | |
| print("=" * 80) | |
| accept_string = 'THE DIFF IS OK!' | |
| answer = input("Accept the additonal diff as part of the release? " | |
| "Type '%s' to accept: " % accept_string) | |
| if answer != accept_string: | |
| print("You did not type '%s'" % accept_string) | |
| print('Aborting dev release for %s' % new_version) | |
| sys.exit(1) | |
| def maybe_check_call(args, cmd): | |
| if args.dry_run: | |
| print('DryRun:', ' '.join(cmd)) | |
| else: | |
| print(' '.join(cmd)) | |
| return subprocess.check_call(cmd) | |
| def prepare_maven(args): | |
| assert args.version | |
| def release_maven(options): | |
| gfiles = [] | |
| for version in args.version: | |
| gfiles.append('/bigstore/r8-releases/raw/%s/r8lib.zip' % version) | |
| release_id = gmaven_publisher_stage(options, gfiles) | |
| print("Staged Release ID " + release_id + ".\n") | |
| gmaven_publisher_stage_redir_test_info( | |
| release_id, "com.android.tools:r8:%s" % args.version[0], | |
| "r8lib.jar") | |
| print() | |
| answer = input("Continue with publishing [y/N]:") | |
| if answer != 'y': | |
| print('Aborting release to Google maven') | |
| sys.exit(1) | |
| gmaven_publisher_publish(args, release_id) | |
| print("") | |
| print("Published. Use the email workflow for approval.") | |
| return release_maven | |
| def bug_fmt(bug): | |
| return "b/%s" % bug | |
| def prepare_studio(args): | |
| assert len(args.version) == 1 | |
| assert args.studio or args.studio_branch | |
| if args.studio: | |
| assert os.path.exists(args.studio), ("Could not find STUDIO path %s" % | |
| args.studio) | |
| def commit_and_upload_studio(path, | |
| options, | |
| git_message, | |
| topic, | |
| presubmit=False): | |
| with utils.ChangedWorkingDirectory(path): | |
| if not options.use_existing_work_branch: | |
| subprocess.check_call( | |
| ['git', 'commit', '-a', '-m', git_message]) | |
| else: | |
| print('Not committing when --use-existing-work-branch. ' + | |
| 'Commit message should be:\n\n' + git_message + '\n') | |
| # Don't upload if requested not to, or if changes are not committed due | |
| # to --use-existing-work-branch | |
| if not options.no_upload and not options.use_existing_work_branch: | |
| cmd = [ | |
| 'repo', 'upload', '.', '--verify', '--current-branch', | |
| f'--topic={topic}' | |
| ] | |
| if presubmit: | |
| cmd.append('--label=Presubmit-Ready+1') | |
| subprocess.run(cmd, input=b'y\n', check=True) | |
| def release_studio_in_checkout(studio, options): | |
| version = options.version[0] | |
| change_name = 'update-r8' | |
| topic = options.topic if options.topic else f'r8-{version}' | |
| tools_base = os.path.join(studio, 'tools', 'base') | |
| prebuilts_tools = os.path.join(studio, 'prebuilts', 'tools') | |
| tools_buildsrc = os.path.join(studio, 'tools', 'buildSrc') | |
| if options.studio: | |
| with utils.ChangedWorkingDirectory(studio): | |
| if not options.use_existing_work_branch: | |
| if not options.yes: | |
| answer = input(f'Abandon branch {change_name} [Y/n]:') | |
| if answer and answer.lower() != 'y': | |
| print(f'Aborting release for {version}') | |
| sys.exit(1) | |
| subprocess.call(['repo', 'abandon', change_name]) | |
| if not options.no_sync: | |
| subprocess.check_call(['repo', 'sync', '-cq', '-j', '16']) | |
| # 1. Update tools/base and run maven_fetch.sh (which updates | |
| # tools/base/bazel/maven/BUILD.maven and fetches prebuilts into | |
| # prebuilts/tools). | |
| previous_version = None | |
| with utils.ChangedWorkingDirectory(tools_base): | |
| if not options.use_existing_work_branch: | |
| subprocess.check_call(['repo', 'start', change_name]) | |
| r8_version_bzl = os.path.join('bazel', 'maven', 'r8-version.bzl') | |
| if os.path.exists(r8_version_bzl): | |
| for line in open(r8_version_bzl, 'r'): | |
| result = re.search(r'R8_VERSION = "([^"]+)"', line) | |
| if result: | |
| previous_version = result.group(1) | |
| break | |
| if not previous_version: | |
| print( | |
| f'ERROR: Could not find previous R8 version in {r8_version_bzl}' | |
| ) | |
| sys.exit(1) | |
| sed(r'R8_VERSION = "[^"]+"', f'R8_VERSION = "{version}"', | |
| r8_version_bzl) | |
| else: | |
| # Look for the version in artifacts.bzl as well for | |
| # compatibility with older studio branches. | |
| artifacts_bzl = os.path.join('bazel', 'maven', 'artifacts.bzl') | |
| for line in open(artifacts_bzl, 'r'): | |
| result = re.search(r'"com\.android\.tools:r8:([^"]+)"', | |
| line) | |
| if result: | |
| previous_version = result.group(1) | |
| break | |
| if not previous_version: | |
| print( | |
| f'ERROR: Could not find previous R8 version in {artifacts_bzl}' | |
| ) | |
| sys.exit(1) | |
| sed(r'"com\.android\.tools:r8:[^"]+"', | |
| f'"com.android.tools:r8:{version}"', artifacts_bzl) | |
| maven_fetch = os.path.join('bazel', 'maven', 'maven_fetch.sh') | |
| utils.print_cmd([maven_fetch]) | |
| subprocess.check_call([maven_fetch]) | |
| with utils.ChangedWorkingDirectory(studio): | |
| cmd = ['tools/base/bazel/bazel', 'shutdown'] | |
| utils.print_cmd(cmd) | |
| subprocess.check_call(cmd) | |
| bugs = '\n'.join(map(lambda b: f'Bug: {b}', | |
| options.bug)) if options.bug else 'Bug: n/a' | |
| git_message_update = f"""Update R8 to version {version} | |
| {bugs} | |
| Test: Existing""" | |
| commit_and_upload_studio(tools_base, options, git_message_update, topic) | |
| # 2. Create CL in prebuilts/tools with fetched artifacts. | |
| with utils.ChangedWorkingDirectory(prebuilts_tools): | |
| if not options.use_existing_work_branch: | |
| subprocess.check_call(['repo', 'start', change_name]) | |
| m2_r8_dir = os.path.join('common', 'm2', 'repository', 'com', | |
| 'android', 'tools', 'r8') | |
| if previous_version != version: | |
| subprocess.check_call([ | |
| 'git', 'rm', '-r', | |
| os.path.join(m2_r8_dir, previous_version) | |
| ]) | |
| subprocess.check_call( | |
| ['git', 'add', os.path.join(m2_r8_dir, version)]) | |
| git_message_prebuilts = f"""Add prebuilts for R8 {version} | |
| Also remove prebuilts for R8 {previous_version} | |
| {bugs} | |
| Test: n/a""" | |
| commit_and_upload_studio(prebuilts_tools, options, | |
| git_message_prebuilts, topic) | |
| # 3. Update tools/buildSrc/base/libs.versions.toml. | |
| with utils.ChangedWorkingDirectory(tools_buildsrc): | |
| if not options.use_existing_work_branch: | |
| subprocess.check_call(['repo', 'start', change_name]) | |
| r8_versions_toml = os.path.join('base', 'r8.versions.toml') | |
| libs_versions_toml = os.path.join('base', 'libs.versions.toml') | |
| if os.path.exists(r8_versions_toml): | |
| sed(r'r8 = "com\.android\.tools:r8:[^"]+"', | |
| f'r8 = "com.android.tools:r8:{version}"', r8_versions_toml) | |
| elif os.path.exists(libs_versions_toml): | |
| # TODO(b/562732980): Remove this branch, as no release branch | |
| # will have libs.versions.toml without r8.versions.toml. | |
| sed(r'r8 = "com\.android\.tools:r8:[^"]+"', | |
| f'r8 = "com.android.tools:r8:{version}"', | |
| libs_versions_toml) | |
| else: | |
| # Update dependencies.properties for compatibility with older | |
| # studio branches. | |
| dependencies_properties = os.path.join( | |
| 'base', 'dependencies.properties') | |
| sed(r'r8 = com\.android\.tools:r8:.*', | |
| f'r8 = com.android.tools:r8:{version}', | |
| dependencies_properties) | |
| commit_and_upload_studio(tools_buildsrc, | |
| options, | |
| git_message_update, | |
| topic, | |
| presubmit=not options.no_presubmit) | |
| def release_studio(options): | |
| assert len(options.version) == 1 | |
| version = options.version[0] | |
| print("Releasing for STUDIO") | |
| if options.dry_run: | |
| return 'DryRun: omitting studio release for %s' % version | |
| if options.studio: | |
| release_studio_in_checkout(options.studio, options) | |
| else: | |
| assert options.studio_branch | |
| with tempfile.TemporaryDirectory( | |
| # Checkout in current working directory, as the Studio project | |
| # is too large to safely go into /tmp. | |
| dir=os.getcwd(), | |
| prefix='studio-release-tmp-') as temp: | |
| with utils.ChangedWorkingDirectory(temp): | |
| cmd = ('REPO_ALLOW_SHALLOW=0 repo init -c -u ' | |
| 'sso://googleplex-android/platform/manifest -b ' | |
| f'{options.studio_branch} --use-superproject ' | |
| '--partial-clone --clone-filter=blob:limit=10k && ' | |
| 'repo sync -c -j16') | |
| utils.print_cmd(cmd) | |
| subprocess.check_call(cmd, shell=True) | |
| release_studio_in_checkout(temp, options) | |
| if not options.yes: | |
| while True: | |
| try: | |
| answer = input( | |
| "Type 'delete' to finish and delete checkout in %s: " | |
| % temp) | |
| if answer == 'delete': | |
| break | |
| except KeyboardInterrupt: | |
| pass | |
| return release_studio | |
| def g4_open(file): | |
| if not os.access(file, os.W_OK): | |
| subprocess.check_call('g4 open %s' % file, shell=True) | |
| def g4_change(version, commit_info): | |
| message = f'Update R8 to {version}' | |
| if version == 'main': | |
| message = f'DO NOT SUBMIT: {message}' | |
| if commit_info: | |
| message += f'\n\n{commit_info}' | |
| return subprocess.check_output(['g4', 'change', '--desc', | |
| f'{message}\n']).decode('utf-8') | |
| def get_cl_id(c4_change_output): | |
| start_index = c4_change_output.find('Change ') + len('Change ') | |
| end_index = c4_change_output.find(' ', start_index) | |
| cl = c4_change_output[start_index:end_index] | |
| assert cl.isdigit() | |
| return cl | |
| def sed(pattern, replace, path): | |
| with open(path, "r") as sources: | |
| lines = sources.readlines() | |
| with open(path, "w") as sources: | |
| for line in lines: | |
| sources.write(re.sub(pattern, replace, line)) | |
| def download_file(version, file, dst): | |
| if version == 'main': | |
| src = os.path.join(utils.LIBS, file) | |
| if os.path.exists(src): | |
| shutil.copyfile(src, dst) | |
| else: | |
| print(f"WARNING: no file found for {src}. Skipping.") | |
| return | |
| dir = 'raw' if len(version) != 40 else 'raw/main' | |
| urllib.request.urlretrieve(('%s/r8-releases/%s/%s/%s' % | |
| (utils.CLOUD_STORAGE_URL, dir, version, file)), | |
| dst) | |
| def download_gfile(gfile, dst): | |
| if not gfile.startswith('/bigstore/r8-releases'): | |
| print('Unexpected gfile prefix for %s' % gfile) | |
| sys.exit(1) | |
| urllib.request.urlretrieve( | |
| '%s/%s' % (utils.CLOUD_STORAGE_URL, gfile[len('/bigstore/'):]), dst) | |
| def blaze_run(target): | |
| return subprocess.check_output('blaze run %s' % target, | |
| shell=True, | |
| stderr=subprocess.STDOUT).decode('utf-8') | |
| def find_r8_version_hash(branch, version): | |
| if not branch.startswith('origin/'): | |
| print('Expected branch to start with origin/') | |
| return 1 | |
| output = subprocess.check_output([ | |
| 'git', 'log', '--pretty=format:%H\t%s', '--grep', | |
| r'^Version [[:digit:]]\+.[[:digit:]]\+.[[:digit:]]\+\(\|-dev\|-alpha[[:digit:]]\+\)$', | |
| branch | |
| ]).decode('utf-8') | |
| for l in output.split('\n'): | |
| (hash, subject) = l.split('\t') | |
| m = re.search('Version (.+)', subject) | |
| if not m: | |
| print('Unable to find a version for line: %s' % l) | |
| continue | |
| if (m.group(1) == version): | |
| return hash | |
| print(f'ERROR: Did not find commit for {version} on branch {branch}') | |
| def find_2nd(string, substring): | |
| return string.find(substring, string.find(substring) + 1) | |
| def branch_from_version(version): | |
| return version[0:find_2nd(version, '.')] | |
| def prepare_google3(args): | |
| assert len(args.version) == 1 | |
| # Check if an existing client exists. | |
| if not args.use_existing_work_branch: | |
| check_no_google3_client(args, args.p4_client) | |
| def release_google3(options): | |
| assert len(options.version) == 1 | |
| version = options.version[0] | |
| print("Releasing for Google 3") | |
| if options.dry_run: | |
| return 'DryRun: omitting g3 release for %s' % version | |
| google3_base = subprocess.check_output( | |
| ['p4', 'g4d', '-f', args.p4_client]).decode('utf-8').rstrip() | |
| third_party_r8 = os.path.join(google3_base, 'third_party', 'java', 'r8') | |
| today = datetime.date.today() | |
| commit_info = 'No info on changes merged.' | |
| with utils.ChangedWorkingDirectory(third_party_r8): | |
| # download files | |
| g4_open('full.jar') | |
| g4_open('src.jar') | |
| g4_open('lib.jar') | |
| g4_open('lib.jar.map') | |
| g4_open('desugar_jdk_libs_configuration.jar') | |
| g4_open('threading-module-blocking.jar') | |
| g4_open('threading-module-single-threaded.jar') | |
| g4_open('proto/keepradius.proto') | |
| g4_open('proto/keepradiussummary.proto') | |
| g4_open('proto/libraryanalyzerresult.proto') | |
| download_file(version, 'r8-full-exclude-deps.jar', 'full.jar') | |
| download_file(version, 'r8-src.jar', 'src.jar') | |
| download_file(version, 'r8lib-exclude-deps.jar', 'lib.jar') | |
| download_file(version, 'r8lib-exclude-deps.jar.map', 'lib.jar.map') | |
| download_file(version, 'desugar_jdk_libs_configuration.jar', | |
| 'desugar_jdk_libs_configuration.jar') | |
| download_file(version, 'threading-module-blocking.jar', | |
| 'threading-module-blocking.jar') | |
| download_file(version, 'threading-module-single-threaded.jar', | |
| 'threading-module-single-threaded.jar') | |
| download_file(version, 'keepradius.proto', 'proto/keepradius.proto') | |
| download_file(version, 'keepradiussummary.proto', | |
| 'proto/keepradiussummary.proto') | |
| download_file(version, 'libraryanalyzerresult.proto', | |
| 'proto/libraryanalyzerresult.proto') | |
| if version != 'main': | |
| g4_open('METADATA') | |
| metadata_path = os.path.join(third_party_r8, 'METADATA') | |
| match_count = 0 | |
| match_count_expected = 10 | |
| match_value = None | |
| version_match_regexp = ( | |
| r'([1-9][0-9]?\.[0-9]{1,2}\.[0-9]{1,3}(?:-dev|-alpha[0-9]+))' | |
| ) | |
| for line in open(metadata_path, 'r'): | |
| result = re.search(version_match_regexp, line) | |
| if result: | |
| match_count = match_count + 1 | |
| if not match_value: | |
| match_value = result.group(1) | |
| else: | |
| if match_value != result.group(1): | |
| print(f"""ERROR: | |
| Multiple pre-release strings ({match_value} and | |
| {result.group(0)}) found in METADATA. Please update | |
| {metadata_path} manually and run again with options | |
| --google3 --use-existing-work-branch. | |
| """) | |
| sys.exit(1) | |
| if match_count != match_count_expected: | |
| print(f"""ERROR: | |
| Could not find the previous pre-release string to replace in METADATA. | |
| Expected to find it mentioned {match_count_expected} times, but found | |
| {match_count} occurrences. Please update {metadata_path} manually and | |
| run again with options --google3 --use-existing-work-branch. | |
| """) | |
| sys.exit(1) | |
| sed(version_match_regexp, version, metadata_path) | |
| sed( | |
| r'\{ year.*\}', | |
| f'{{ year: {today.year} month: {today.month} day: {today.day} }}', | |
| metadata_path) | |
| subprocess.check_output('chmod u+w *', shell=True) | |
| previous_version = match_value | |
| if (not (version.endswith('-dev') or '-alpha' in version) or | |
| not (previous_version.endswith('-dev') or | |
| '-alpha' in previous_version)): | |
| print( | |
| f'ERROR: At least one of {version} (new version) ' + | |
| f'and {previous_version} (previous version) is not a -dev or -alpha version. ' | |
| + 'Expected both to be.') | |
| sys.exit(1) | |
| print(f'Previous version was: {previous_version}') | |
| with utils.TempDir() as temp: | |
| subprocess.check_call(['git', 'clone', utils.REPO_SOURCE, temp]) | |
| with utils.ChangedWorkingDirectory(temp): | |
| current_version_hash = find_r8_version_hash( | |
| 'origin/' + branch_from_version(previous_version), | |
| previous_version) | |
| new_version_hash = find_r8_version_hash( | |
| 'origin/' + branch_from_version(version), version) | |
| if not current_version_hash or not new_version_hash: | |
| print( | |
| 'ERROR: Failed to generate merged commits log, missing version' | |
| ) | |
| sys.exit(1) | |
| commits_merged = subprocess.check_output([ | |
| 'git', 'log', '--oneline', | |
| f"{current_version_hash}..{new_version_hash}" | |
| ]).decode('utf-8') | |
| if len(commits_merged) == 0: | |
| print( | |
| 'ERROR: Failed to generate merged commits log, commit log is empty' | |
| ) | |
| sys.exit(1) | |
| commit_info = ( | |
| f'Commits merged (since {previous_version}):\n' + | |
| f'{commits_merged}\n' + | |
| f'See https://r8.googlesource.com/r8/+log/{new_version_hash}' | |
| ) | |
| with utils.ChangedWorkingDirectory(google3_base): | |
| blaze_result = blaze_run('//third_party/java/r8:d8 -- --version') | |
| assert version in blaze_result | |
| if not options.no_upload: | |
| change_result = g4_change(version, commit_info) | |
| change_result += 'Run \'(g4d ' + args.p4_client \ | |
| + ' && tap_presubmit -p all --train -c ' \ | |
| + get_cl_id(change_result) + ')\' for running TAP global' \ | |
| + ' presubmit using the train.\n' \ | |
| + 'Run \'(g4d ' + args.p4_client \ | |
| + ' && tap_presubmit -p all --notrain --detach --email' \ | |
| + ' --skip_flaky_targets --skip_already_failing -c ' \ | |
| + get_cl_id(change_result) + ')\' for running an isolated' \ | |
| + ' TAP global presubmit.' | |
| return change_result | |
| return release_google3 | |
| def update_desugar_library_in_studio(args): | |
| assert os.path.exists(args.studio), ("Could not find STUDIO path %s" % | |
| args.studio) | |
| def make_release(args): | |
| library_version = args.update_desugar_library_in_studio[0] | |
| configuration_version = args.update_desugar_library_in_studio[1] | |
| change_name = 'update-desugar-library-dependencies' | |
| with utils.ChangedWorkingDirectory(args.studio): | |
| if not args.use_existing_work_branch: | |
| subprocess.call(['repo', 'abandon', change_name]) | |
| if not args.no_sync: | |
| subprocess.check_call(['repo', 'sync', '-cq', '-j', '16']) | |
| cmd = [ | |
| 'tools/base/bazel/bazel', 'run', | |
| '//tools/base/bazel:add_dependency', '--', | |
| '--repo=https://maven.google.com com.android.tools:desugar_jdk_libs:%s' | |
| % library_version | |
| ] | |
| utils.print_cmd(cmd) | |
| subprocess.check_call(" ".join(cmd), shell=True) | |
| cmd = ['tools/base/bazel/bazel', 'shutdown'] | |
| utils.print_cmd(cmd) | |
| subprocess.check_call(cmd) | |
| prebuilts_tools = os.path.join(args.studio, 'prebuilts', 'tools') | |
| with utils.ChangedWorkingDirectory(prebuilts_tools): | |
| if not args.use_existing_work_branch: | |
| with utils.ChangedWorkingDirectory(prebuilts_tools): | |
| subprocess.check_call(['repo', 'start', change_name]) | |
| m2_dir = os.path.join('common', 'm2', 'repository', 'com', | |
| 'android', 'tools') | |
| subprocess.check_call([ | |
| 'git', 'add', | |
| os.path.join(m2_dir, DESUGAR_JDK_LIBS, library_version) | |
| ]) | |
| subprocess.check_call([ | |
| 'git', 'add', | |
| os.path.join(m2_dir, DESUGAR_JDK_LIBS_CONFIGURATION, | |
| configuration_version) | |
| ]) | |
| git_message = ("""Update library desugaring dependencies | |
| com.android.tools:desugar_jdk_libs:%s | |
| com.android.tools:desugar_jdk_libs_configuration:%s | |
| Bug: %s | |
| Test: L8ToolTest, L8DexDesugarTest""" % | |
| (library_version, configuration_version, | |
| '\nBug: '.join(map(bug_fmt, args.bug)))) | |
| if not args.use_existing_work_branch: | |
| subprocess.check_call( | |
| ['git', 'commit', '-a', '-m', git_message]) | |
| else: | |
| print('Not committing when --use-existing-work-branch. ' + | |
| 'Commit message should be:\n\n' + git_message + '\n') | |
| # Don't upload if requested not to, or if changes are not committed due | |
| # to --use-existing-work-branch | |
| if not args.no_upload and not args.use_existing_work_branch: | |
| process = subprocess.Popen(['repo', 'upload', '.', '--verify'], | |
| stdin=subprocess.PIPE) | |
| return process.communicate(input='y\n')[0] | |
| return make_release | |
| def prepare_desugar_library(args): | |
| def make_release(args): | |
| library_version = args.desugar_library[0] | |
| configuration_version = args.desugar_library[1] | |
| # TODO(b/237636871): Cleanup and generalize. | |
| if (not (library_version.startswith('1.1') or | |
| library_version.startswith('1.2') or | |
| library_version.startswith('2.0') or | |
| library_version.startswith('2.1'))): | |
| print( | |
| "Release script does not support desugared library version %s" % | |
| library_version) | |
| sys.exit(1) | |
| postfixes = [''] | |
| if library_version.startswith('1.2'): | |
| postfixes = ['_legacy'] | |
| if library_version.startswith('2.0') or library_version.startswith( | |
| '2.1'): | |
| postfixes = ['_minimal', '', '_nio'] | |
| with utils.TempDir() as temp: | |
| with utils.ChangedWorkingDirectory(temp): | |
| artifacts = [] | |
| for postfix in postfixes: | |
| group_postfix = ('' if postfix == '_legacy' else postfix) | |
| archive_postfix = (postfix | |
| if library_version.startswith('1.1') else | |
| '_jdk11' + postfix) | |
| library_jar = DESUGAR_JDK_LIBS + postfix + '.jar' | |
| library_archive = DESUGAR_JDK_LIBS + archive_postfix + '.zip' | |
| configuration_archive = DESUGAR_JDK_LIBS_CONFIGURATION + archive_postfix + '.zip' | |
| library_gfile = ('/bigstore/r8-releases/raw/%s/%s/%s' % | |
| (DESUGAR_JDK_LIBS + group_postfix, | |
| library_version, library_archive)) | |
| configuration_gfile = ( | |
| '/bigstore/r8-releases/raw/main/%s/%s' % | |
| (configuration_version, configuration_archive)) | |
| download_gfile(library_gfile, library_archive) | |
| download_gfile(configuration_gfile, configuration_archive) | |
| check_configuration(configuration_archive, group_postfix) | |
| artifacts.append(library_gfile) | |
| artifacts.append(configuration_gfile) | |
| release_id = gmaven_publisher_stage(args, artifacts) | |
| print("Staged Release ID " + release_id + ".\n") | |
| library_artifact_id = \ | |
| '%s:%s:%s' % (ANDROID_TOOLS_PACKAGE, DESUGAR_JDK_LIBS, library_version) | |
| gmaven_publisher_stage_redir_test_info(release_id, | |
| library_artifact_id, | |
| library_jar) | |
| print("") | |
| answer = input("Continue with publishing [y/N]:") | |
| if answer != 'y': | |
| print('Aborting release to Google maven') | |
| sys.exit(1) | |
| gmaven_publisher_publish(args, release_id) | |
| print("") | |
| print("Published. Use the email workflow for approval.") | |
| return make_release | |
| def check_configuration(configuration_archive, postfix): | |
| zip = zipfile.ZipFile(configuration_archive) | |
| zip.extractall() | |
| dirs = os.listdir( | |
| os.path.join('com', 'android', 'tools', | |
| DESUGAR_JDK_LIBS_CONFIGURATION + postfix)) | |
| if len(dirs) != 1: | |
| print('Unexpected archive content, %s' + dirs) | |
| sys.exit(1) | |
| version = dirs[0] | |
| pom_file = os.path.join( | |
| 'com', 'android', 'tools', DESUGAR_JDK_LIBS_CONFIGURATION + postfix, | |
| version, | |
| '%s-%s.pom' % (DESUGAR_JDK_LIBS_CONFIGURATION + postfix, version)) | |
| version_from_pom = extract_version_from_pom(pom_file) | |
| if version != version_from_pom: | |
| print('Version mismatch, %s != %s' % (version, version_from_pom)) | |
| sys.exit(1) | |
| def check_no_google3_client(args, client_name): | |
| if not args.use_existing_work_branch: | |
| clients = subprocess.check_output('g4 myclients', | |
| shell=True).decode('utf-8') | |
| if ':%s:' % client_name in clients: | |
| if args.delete_work_branch: | |
| subprocess.check_call('g4 citc -d -f %s' % client_name, | |
| shell=True) | |
| else: | |
| print(("Remove the existing '%s' client before continuing " + | |
| "(force delete: 'g4 citc -d -f %s'), " + | |
| "or use either --use-existing-work-branch or " + | |
| "--delete-work-branch.") % (client_name, client_name)) | |
| sys.exit(1) | |
| def extract_version_from_pom(pom_file): | |
| ns = "http://maven.apache.org/POM/4.0.0" | |
| xml.etree.ElementTree.register_namespace('', ns) | |
| tree = xml.etree.ElementTree.ElementTree() | |
| tree.parse(pom_file) | |
| return tree.getroot().find("{%s}version" % ns).text | |
| GMAVEN_PUBLISH_STAGE_RELEASE_ID_PATTERN = re.compile( | |
| r'Release ID = ([0-9a-f-]+)') | |
| def gmaven_publisher_stage(args, gfiles): | |
| if args.dry_run: | |
| print('Dry-run, would have staged %s' % gfiles) | |
| return 'dry-run-release-id' | |
| print("Staging: %s" % ', '.join(gfiles)) | |
| print("") | |
| cmd = [ | |
| GMAVEN_PUBLISHER, 'stage', '--ack_deprecated', '--gfile', | |
| ','.join(gfiles) | |
| ] | |
| output = subprocess.check_output(cmd) | |
| # Expect output to contain: | |
| # [INFO] 06/19/2020 09:35:12 CEST: >>>>>>>>>> Staged | |
| # [INFO] 06/19/2020 09:35:12 CEST: Release ID = 9171d015-18f6-4a90-9984-1c362589dc1b | |
| # [INFO] 06/19/2020 09:35:12 CEST: Stage Path = /bigstore/studio_staging/maven2/sgjesse/9171d015-18f6-4a90-9984-1c362589dc1b | |
| matches = GMAVEN_PUBLISH_STAGE_RELEASE_ID_PATTERN.findall( | |
| output.decode("utf-8")) | |
| if len(matches) != 1: | |
| print("Could not determine the release ID from the gmaven_publisher " + | |
| "output. Expected a line with 'Release ID = <release id>'.") | |
| print("Output was:") | |
| print(output) | |
| sys.exit(1) | |
| print(output) | |
| release_id = matches[0] | |
| return release_id | |
| def gmaven_publisher_stage_redir_test_info(release_id, artifact, dst): | |
| redir_command = ("/google/data/ro/teams/android-devtools-infra/tools/redir " | |
| + "--alsologtostderr " + | |
| "--gcs_bucket_path=/bigstore/gmaven-staging/${USER}/%s " + | |
| "--port=1480") % release_id | |
| get_command = ( | |
| "mvn org.apache.maven.plugins:maven-dependency-plugin:2.4:get " + | |
| "-Dmaven.repo.local=/tmp/maven_repo_local " + | |
| "-DremoteRepositories=http://localhost:1480 " + "-Dartifact=%s " + | |
| "-Ddest=%s") % (artifact, dst) | |
| print("""To test the staged content with 'redir' run: | |
| %s | |
| Then add the following repository to settings.gradle.kts (Kotlin Script) to | |
| search the 'redir' repository: | |
| dependencyResolutionManagement { | |
| repositories { | |
| maven { | |
| url = uri("http://localhost:1480") | |
| isAllowInsecureProtocol = true | |
| } | |
| } | |
| } | |
| or the following to settings.gradle (Groovy); | |
| dependencyResolutionManagement { | |
| repositories { | |
| maven { | |
| url 'http://localhost:1480' | |
| allowInsecureProtocol true | |
| } | |
| } | |
| } | |
| and add the following repository to gradle.build.kts (Kotlin Script) for the | |
| staged version: | |
| coreLibraryDesugaring("%s") { | |
| isChanging = true | |
| } | |
| or the following to settings.gradle (Groovy); | |
| dependencies { | |
| coreLibraryDesugaring('%s') { | |
| changing = true | |
| } | |
| } | |
| Use this commands to get artifact from 'redir': | |
| rm -rf /tmp/maven_repo_local | |
| %s | |
| """ % (redir_command, artifact, artifact, get_command)) | |
| def gmaven_publisher_publish(args, release_id): | |
| if args.dry_run: | |
| print('Dry-run, would have published %s' % release_id) | |
| return | |
| cmd = [GMAVEN_PUBLISHER, 'publish', release_id] | |
| output = subprocess.check_output(cmd) | |
| def branch_change_diff(diff, old_version, new_version): | |
| invalid_line = None | |
| for line in str(diff).splitlines(): | |
| if line.startswith('-R8') and \ | |
| line != "-R8_DEV_BRANCH = '%s'" % old_version: | |
| print(line) | |
| invalid_line = line | |
| elif line.startswith('+R8') and \ | |
| line != "+R8_DEV_BRANCH = '%s'" % new_version: | |
| print(line) | |
| invalid_line = line | |
| return invalid_line | |
| def validate_branch_change_diff(version_diff_output, old_version, new_version): | |
| invalid = branch_change_diff(version_diff_output, old_version, new_version) | |
| if invalid: | |
| print("") | |
| print( | |
| "The diff for the branch change in tools/release.py is not as expected:" | |
| ) | |
| print("") | |
| print("=" * 80) | |
| print(version_diff_output) | |
| print("=" * 80) | |
| print("") | |
| print("Validate the uploaded CL before landing.") | |
| print("") | |
| def prepare_branch(args): | |
| if (len(args.new_dev_branch) < 1 or len(args.new_dev_branch) > 2): | |
| print("One or two arguments required for --new-dev-branch") | |
| sys.exit(1) | |
| branch_version = args.new_dev_branch[0] | |
| current_semver = utils.check_basic_semver_version( | |
| R8_DEV_BRANCH, ", current release branch version should be x.y", 2) | |
| semver = utils.check_basic_semver_version( | |
| branch_version, ", release branch version should be x.y", 2) | |
| if not semver.larger_than(current_semver): | |
| print('New branch version "' + branch_version + | |
| '" must be strictly larger than the current "' + R8_DEV_BRANCH + | |
| '"') | |
| sys.exit(1) | |
| def gerrit_create_branch(branch_name, hash): | |
| data = json.dumps({"revision": hash}) | |
| cmd = ' '.join([ | |
| 'gob-curl', '--header', | |
| '"Content-Type: application/json; charset=UTF-8"', '--request', | |
| 'PUT', '--data', "'{data}'".format(data=data), | |
| 'https://r8-review.git.corp.google.com/a/projects/r8/branches/{branch_name}' | |
| .format(branch_name=branch_name) | |
| ]) | |
| print(cmd) | |
| result = subprocess.check_output(cmd, | |
| stderr=subprocess.STDOUT, | |
| shell=True) | |
| print(result) | |
| def make_branch(options): | |
| with utils.TempDir() as temp: | |
| subprocess.check_call(['git', 'clone', utils.REPO_SOURCE, temp]) | |
| with utils.ChangedWorkingDirectory(temp): | |
| if len(options.new_dev_branch) == 1: | |
| # Calculate the usual branch hash. | |
| subprocess.check_call( | |
| ['git', 'fetch', 'origin', R8_DEV_BRANCH]) | |
| hashes = subprocess.check_output([ | |
| 'git', 'show', '-s', '--pretty=%P', | |
| 'origin/%s~1' % R8_DEV_BRANCH | |
| ]).decode('utf-8').strip() | |
| if (len(hashes.split()) != 2): | |
| print( | |
| 'Expected two parent hashes for commit origin/%s~1' | |
| % R8_DEV_BRANCH) | |
| sys.exit(0) | |
| commithash = hashes.split()[1] | |
| print() | |
| print('Calculated branch hash: %s' % commithash) | |
| print( | |
| 'Please double check that this is the correct branch hash. It' | |
| ' is obtained as the second parent of origin/%s~1.' % | |
| R8_DEV_BRANCH) | |
| print( | |
| 'If not rerun the script passing an explicit hash to branch from.' | |
| ) | |
| else: | |
| commithash = options.new_dev_branch[1] | |
| print() | |
| print('Using explicit branch hash %s' % commithash) | |
| print() | |
| answer = input('Create new branch %s branch from %s [y/N]:' % | |
| (branch_version, commithash)) | |
| if answer != 'y': | |
| print('Aborting preparing branch for %s' % branch_version) | |
| sys.exit(1) | |
| gerrit_create_branch(branch_version, commithash) | |
| # Fetch and checkout the new branch created through the Gerrit UI. | |
| subprocess.check_call( | |
| ['git', 'fetch', 'origin', branch_version]) | |
| subprocess.check_call(['git', 'checkout', branch_version]) | |
| # Rewrite the version on the branch, commit and validate. | |
| old_version = 'main' | |
| if semver.larger_than(utils.SemanticVersion(9, 5, None, None)): | |
| full_version = branch_version + '.0-alpha01' | |
| else: | |
| full_version = branch_version + '.0-dev' | |
| version_prefix = 'public static final String LABEL = "' | |
| sed(version_prefix + old_version, version_prefix + full_version, | |
| R8_VERSION_FILE) | |
| git_utils.git_commit( | |
| git_utils.version_commit_message(full_version)) | |
| version_diff_output = subprocess.check_output( | |
| ['git', 'diff', '%s..HEAD' % commithash]) | |
| validate_version_change_diff(version_diff_output, old_version, | |
| full_version) | |
| if options.dry_run: | |
| input( | |
| 'DryRun: check %s for content of version %s [enter to continue]:' | |
| % (temp, branch_version)) | |
| # Double check that we want to create a new release branch. | |
| if not options.dry_run: | |
| answer = input('Continue with branch for %s [y/N]:' % | |
| branch_version) | |
| if answer != 'y': | |
| print('Aborting preparing branch for %s' % | |
| branch_version) | |
| sys.exit(1) | |
| maybe_check_call(options, | |
| ['git', 'cl', 'upload', '--bypass-hooks']) | |
| print( | |
| 'Updating tools/r8_release.py to make new dev releases on %s' | |
| % branch_version) | |
| subprocess.check_call( | |
| ['git', 'new-branch', 'update-release-script']) | |
| # Check this file for the setting of the current dev branch. | |
| result = None | |
| for line in open(THIS_FILE_RELATIVE, 'r'): | |
| result = re.match(r"^R8_DEV_BRANCH = '(\d+).(\d+)'", line) | |
| if result: | |
| break | |
| if not result or not result.group(1): | |
| print('Failed to find version label in %s' % | |
| THIS_FILE_RELATIVE) | |
| sys.exit(1) | |
| # Update this file with the new dev branch. | |
| sed( | |
| "R8_DEV_BRANCH = '%s.%s" % | |
| (result.group(1), result.group(2)), | |
| "R8_DEV_BRANCH = '%s.%s" % | |
| (str(semver.major), str(semver.minor)), THIS_FILE_RELATIVE) | |
| message = \ | |
| 'Prepare %s for branch %s' % (THIS_FILE_RELATIVE, branch_version) | |
| subprocess.check_call(['git', 'commit', '-a', '-m', message]) | |
| branch_diff_output = subprocess.check_output( | |
| ['git', 'diff', 'HEAD~']) | |
| validate_branch_change_diff(branch_diff_output, R8_DEV_BRANCH, | |
| branch_version) | |
| if options.dry_run: | |
| input( | |
| 'DryRun: check %s for content of version main [enter to continue]:' | |
| % temp) | |
| maybe_check_call(options, | |
| ['git', 'cl', 'upload', '-f', '-m', message]) | |
| print('') | |
| print('Make sure to:') | |
| print(' * send out the two branch change CL for review' | |
| ' (on %s and main).' % branch_version) | |
| print( | |
| ' * promote previous -dev branch to stable by running ' | |
| '"tools/cherry-pick.py --promote-dev --branch <previous version>"' | |
| ) | |
| print('') | |
| return make_branch | |
| def parse_options(): | |
| result = argparse.ArgumentParser(description='Release r8') | |
| group = result.add_mutually_exclusive_group() | |
| group.add_argument('--dev-release', | |
| metavar=('<main hash>'), | |
| help='The hash to use for the new dev version of R8') | |
| group.add_argument( | |
| '--version', | |
| metavar=('<version(s)>'), | |
| default=[], | |
| action='append', | |
| help= | |
| 'The new version(s) of R8 (e.g., 1.4.51) to release to selected channels' | |
| ) | |
| group.add_argument( | |
| '--desugar-library', | |
| nargs=2, | |
| metavar=('<version>', '<configuration hash>'), | |
| help='The new version of com.android.tools:desugar_jdk_libs') | |
| group.add_argument( | |
| '--update-desugar-library-in-studio', | |
| nargs=2, | |
| metavar=('<version>', '<configuration version>'), | |
| help='Update studio mirror of com.android.tools:desugar_jdk_libs') | |
| group.add_argument('--new-dev-branch', | |
| nargs='+', | |
| metavar=('<version>', '<branch hash>'), | |
| help=('Prepare new branch for a version line (e.g. 8.0)' | |
| ' Suggested branch hash is calculated ' | |
| ' if not explicitly specified')) | |
| result.add_argument('--reviewer', | |
| metavar=('<reviewer(s)>'), | |
| default=[], | |
| action='append', | |
| help='Rewiever(s) for the cherry-pick(s) ' | |
| '(adds @google.com if missing)') | |
| result.add_argument('--send-mail', | |
| '--send_mail', | |
| default=False, | |
| action='store_true', | |
| help='Send Gerrit review request right away') | |
| result.add_argument('--dev-pre-cherry-pick', | |
| metavar=('<main hash(s)>'), | |
| default=[], | |
| action='append', | |
| help='List of commits to cherry pick before doing full ' | |
| 'merge, mostly used for reverting cherry picks') | |
| result.add_argument('--no-sync', | |
| '--no_sync', | |
| default=False, | |
| action='store_true', | |
| help='Do not sync repos before uploading') | |
| result.add_argument('--bug', | |
| metavar=('<bug(s)>'), | |
| default=[], | |
| action='append', | |
| help='List of bugs for release version') | |
| studio_group = result.add_mutually_exclusive_group() | |
| studio_group.add_argument( | |
| '--studio', | |
| metavar=('<path>'), | |
| help='Release for studio by setting the path to a studio ' | |
| 'checkout') | |
| studio_group.add_argument( | |
| '--studio-branch', | |
| '--studio_branch', | |
| metavar=('<branch name>'), | |
| help='Release for studio by setting the branch name to release to') | |
| result.add_argument('--topic', | |
| default=None, | |
| metavar=('<topic>'), | |
| help='Gerrit topic name when releasing for studio ' | |
| '(default: r8-<version>)') | |
| result.add_argument('--maven', | |
| default=False, | |
| action='store_true', | |
| help='Release to Google Maven') | |
| result.add_argument('--google3', | |
| default=False, | |
| action='store_true', | |
| help='Release for google 3') | |
| result.add_argument('--p4-client', | |
| default='update-r8', | |
| metavar=('<client name>'), | |
| help='P4 client name for google 3') | |
| result.add_argument('--use-existing-work-branch', | |
| '--use_existing_work_branch', | |
| default=False, | |
| action='store_true', | |
| help='Use existing work branch/CL in studio/google3') | |
| result.add_argument('--delete-work-branch', | |
| '--delete_work_branch', | |
| default=False, | |
| action='store_true', | |
| help='Delete CL in google3') | |
| result.add_argument('--no-upload', | |
| '--no_upload', | |
| default=False, | |
| action='store_true', | |
| help="Don't upload for code review") | |
| result.add_argument('--no-presubmit', | |
| '--no_presubmit', | |
| default=False, | |
| action='store_true', | |
| help="Don't start presubmit on uploaded changes") | |
| result.add_argument('--yes', | |
| default=False, | |
| action='store_true', | |
| help='Answer "yes" to all questions') | |
| result.add_argument( | |
| '--dry-run', | |
| default=False, | |
| action='store_true', | |
| help='Only perform non-commiting tasks and print others.') | |
| result.add_argument('--dry-run-output', | |
| '--dry_run_output', | |
| default=os.getcwd(), | |
| metavar=('<path>'), | |
| help='Location for dry run output.') | |
| args = result.parse_args() | |
| if (args.studio or | |
| args.studio_branch) and not args.update_desugar_library_in_studio: | |
| if len(args.version) != 1: | |
| print("ERROR: only one version supported for studio") | |
| sys.exit(1) | |
| semver = utils.check_basic_semver_version(args.version[0], | |
| allow_prerelease=True) | |
| if not semver.larger_than(utils.SemanticVersion(9, 5, 17, 'dev')): | |
| print("ERROR: Releasing to studio is only supported for R8 version " | |
| "9.5.18-dev or higher") | |
| sys.exit(1) | |
| if args.google3: | |
| if len(args.version) != 1: | |
| print("ERROR: only one version supported for google 3") | |
| sys.exit(1) | |
| if not ('-dev' in args.version[0] or '-alpha' in args.version[0]): | |
| print( | |
| "WARNING: You should not roll a release version into google 3") | |
| return args | |
| def main(): | |
| args = parse_options() | |
| targets_to_run = [] | |
| if args.new_dev_branch: | |
| if args.google3 or args.studio or args.studio_branch or args.maven: | |
| print('Cannot create a branch and roll at the same time.') | |
| sys.exit(1) | |
| targets_to_run.append(prepare_branch(args)) | |
| if args.dev_release: | |
| if args.google3 or args.studio or args.studio_branch or args.maven: | |
| print('Cannot create a dev release and roll at the same time.') | |
| sys.exit(1) | |
| targets_to_run.append(prepare_release(args)) | |
| utils.check_gcert() | |
| if args.google3: | |
| targets_to_run.append(prepare_google3(args)) | |
| if (args.studio or | |
| args.studio_branch) and not args.update_desugar_library_in_studio: | |
| targets_to_run.append(prepare_studio(args)) | |
| if args.maven: | |
| targets_to_run.append(prepare_maven(args)) | |
| if args.desugar_library: | |
| targets_to_run.append(prepare_desugar_library(args)) | |
| if args.update_desugar_library_in_studio: | |
| if not args.studio: | |
| print("--studio required") | |
| sys.exit(1) | |
| if args.bug == []: | |
| print( | |
| "Update studio mirror of com.android.tools:desugar_jdk_libs " + | |
| "requires at least one bug by using '--bug'") | |
| sys.exit(1) | |
| targets_to_run.append(update_desugar_library_in_studio(args)) | |
| final_results = [] | |
| for target_closure in targets_to_run: | |
| final_results.append(target_closure(args)) | |
| print('\n\n**************************************************************') | |
| print('PRINTING SUMMARY') | |
| print('**************************************************************\n\n') | |
| for result in final_results: | |
| if result is not None: | |
| print(result) | |
| if __name__ == '__main__': | |
| sys.exit(main()) |