Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 1 | #!/usr/bin/env python3 |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 2 | # Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file |
| 3 | # for details. All rights reserved. Use of this source code is governed by a |
| 4 | # BSD-style license that can be found in the LICENSE file. |
| 5 | |
| 6 | import argparse |
| 7 | import datetime |
| 8 | import os.path |
| 9 | import re |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 10 | import subprocess |
| 11 | import sys |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 12 | import urllib.request |
Søren Gjesse | 2d6e937 | 2020-11-04 08:17:28 +0100 | [diff] [blame] | 13 | import xml.etree.ElementTree |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 14 | import zipfile |
Ian Zerny | cf1eb3c | 2020-09-24 08:27:23 +0200 | [diff] [blame] | 15 | |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 16 | import utils |
| 17 | |
Søren Gjesse | aa83a16 | 2022-08-25 09:33:29 +0200 | [diff] [blame] | 18 | R8_DEV_BRANCH = '8.0' |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 19 | R8_VERSION_FILE = os.path.join( |
| 20 | 'src', 'main', 'java', 'com', 'android', 'tools', 'r8', 'Version.java') |
Søren Gjesse | 2725159 | 2019-11-06 17:35:23 +0100 | [diff] [blame] | 21 | THIS_FILE_RELATIVE = os.path.join('tools', 'r8_release.py') |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 22 | GMAVEN_PUBLISHER = '/google/bin/releases/android-devtools/gmaven/publisher/gmaven-publisher' |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 23 | |
| 24 | DESUGAR_JDK_LIBS = 'desugar_jdk_libs' |
| 25 | DESUGAR_JDK_LIBS_CONFIGURATION = DESUGAR_JDK_LIBS + '_configuration' |
| 26 | ANDROID_TOOLS_PACKAGE = 'com.android.tools' |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 27 | |
Søren Gjesse | 07b6aea | 2019-12-12 11:11:58 +0100 | [diff] [blame] | 28 | GITHUB_DESUGAR_JDK_LIBS = 'https://github.com/google/desugar_jdk_libs' |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 29 | |
Morten Krogh-Jespersen | d86a301 | 2020-02-21 15:06:13 +0100 | [diff] [blame] | 30 | def checkout_r8(temp, branch): |
| 31 | subprocess.check_call(['git', 'clone', utils.REPO_SOURCE, temp]) |
| 32 | with utils.ChangedWorkingDirectory(temp): |
| 33 | subprocess.check_call([ |
| 34 | 'git', |
| 35 | 'new-branch', |
| 36 | '--upstream', |
| 37 | 'origin/%s' % branch, |
| 38 | 'dev-release']) |
| 39 | return temp |
| 40 | |
| 41 | |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 42 | def prepare_release(args): |
| 43 | if args.version: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 44 | print("Cannot manually specify version when making a dev release.") |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 45 | sys.exit(1) |
| 46 | |
| 47 | def make_release(args): |
| 48 | commithash = args.dev_release |
| 49 | |
| 50 | with utils.TempDir() as temp: |
Morten Krogh-Jespersen | d86a301 | 2020-02-21 15:06:13 +0100 | [diff] [blame] | 51 | with utils.ChangedWorkingDirectory(checkout_r8(temp, R8_DEV_BRANCH)): |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 52 | # Compute the current and new version on the branch. |
| 53 | result = None |
| 54 | for line in open(R8_VERSION_FILE, 'r'): |
| 55 | result = re.match( |
| 56 | r'.*LABEL = "%s\.(\d+)\-dev";' % R8_DEV_BRANCH, line) |
| 57 | if result: |
| 58 | break |
| 59 | if not result or not result.group(1): |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 60 | print('Failed to find version label matching %s(\d+)-dev'\ |
| 61 | % R8_DEV_BRANCH) |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 62 | sys.exit(1) |
| 63 | try: |
| 64 | patch_version = int(result.group(1)) |
| 65 | except ValueError: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 66 | print('Failed to convert version to integer: %s' % result.group(1)) |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 67 | |
| 68 | old_version = '%s.%s-dev' % (R8_DEV_BRANCH, patch_version) |
| 69 | version = '%s.%s-dev' % (R8_DEV_BRANCH, patch_version + 1) |
| 70 | |
Rico Wind | 1b52acf | 2021-03-21 12:36:55 +0100 | [diff] [blame] | 71 | # Verify that the merge point from main is not empty. |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 72 | merge_diff_output = subprocess.check_output([ |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 73 | 'git', 'diff', 'HEAD..%s' % commithash]).decode('utf-8') |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 74 | other_diff = version_change_diff( |
Rico Wind | 1b52acf | 2021-03-21 12:36:55 +0100 | [diff] [blame] | 75 | merge_diff_output, old_version, "main") |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 76 | if not other_diff: |
Rico Wind | 1b52acf | 2021-03-21 12:36:55 +0100 | [diff] [blame] | 77 | print('Merge point from main (%s)' % commithash, \ |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 78 | 'is the same as exiting release (%s).' % old_version) |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 79 | sys.exit(1) |
| 80 | |
Rico Wind | 140a564 | 2019-11-26 10:44:21 +0100 | [diff] [blame] | 81 | if args.dev_pre_cherry_pick: |
| 82 | for pre_commit in args.dev_pre_cherry_pick: |
| 83 | subprocess.check_call([ |
| 84 | 'git', 'cherry-pick', '--no-edit', pre_commit]) |
| 85 | |
Rico Wind | 1b52acf | 2021-03-21 12:36:55 +0100 | [diff] [blame] | 86 | # Merge the desired commit from main on to the branch. |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 87 | subprocess.check_call([ |
| 88 | 'git', 'merge', '--no-ff', '--no-edit', commithash]) |
| 89 | |
| 90 | # Rewrite the version, commit and validate. |
| 91 | sed(old_version, version, R8_VERSION_FILE) |
| 92 | |
| 93 | subprocess.check_call([ |
Ian Zerny | 3224c81 | 2019-11-01 08:12:04 +0100 | [diff] [blame] | 94 | 'git', 'commit', '-a', '-m', 'Version %s' % version]) |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 95 | |
| 96 | version_diff_output = subprocess.check_output([ |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 97 | 'git', 'diff', '%s..HEAD' % commithash]).decode('utf-8') |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 98 | |
Rico Wind | 1b52acf | 2021-03-21 12:36:55 +0100 | [diff] [blame] | 99 | validate_version_change_diff(version_diff_output, "main", version) |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 100 | |
| 101 | # Double check that we want to push the release. |
| 102 | if not args.dry_run: |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 103 | answer = input('Publish dev release version %s [y/N]:' % version) |
| 104 | if answer != 'y': |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 105 | print('Aborting dev release for %s' % version) |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 106 | sys.exit(1) |
| 107 | |
| 108 | maybe_check_call(args, [ |
| 109 | 'git', 'push', 'origin', 'HEAD:%s' % R8_DEV_BRANCH]) |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 110 | maybe_tag(args, version) |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 111 | |
| 112 | return "%s dev version %s from hash %s" % ( |
| 113 | 'DryRun: omitted publish of' if args.dry_run else 'Published', |
| 114 | version, |
| 115 | commithash) |
| 116 | |
| 117 | return make_release |
| 118 | |
| 119 | |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 120 | def maybe_tag(args, version): |
| 121 | maybe_check_call(args, [ |
| 122 | 'git', 'tag', '-a', version, '-m', '"%s"' % version]) |
| 123 | maybe_check_call(args, [ |
| 124 | 'git', 'push', 'origin', 'refs/tags/%s' % version]) |
| 125 | |
Morten Krogh-Jespersen | d86a301 | 2020-02-21 15:06:13 +0100 | [diff] [blame] | 126 | |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 127 | def version_change_diff(diff, old_version, new_version): |
| 128 | invalid_line = None |
Søren Gjesse | 25ef552 | 2021-05-05 08:17:00 +0200 | [diff] [blame] | 129 | for line in str(diff).splitlines(): |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 130 | if line.startswith('- ') and \ |
| 131 | line != '- public static final String LABEL = "%s";' % old_version: |
| 132 | invalid_line = line |
| 133 | elif line.startswith('+ ') and \ |
| 134 | line != '+ public static final String LABEL = "%s";' % new_version: |
| 135 | invalid_line = line |
| 136 | return invalid_line |
| 137 | |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 138 | |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 139 | def validate_version_change_diff(version_diff_output, old_version, new_version): |
| 140 | invalid = version_change_diff(version_diff_output, old_version, new_version) |
| 141 | if invalid: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 142 | print("Unexpected diff:") |
| 143 | print("=" * 80) |
| 144 | print(version_diff_output) |
| 145 | print("=" * 80) |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 146 | accept_string = 'THE DIFF IS OK!' |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 147 | answer = input( |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 148 | "Accept the additonal diff as part of the release? " |
| 149 | "Type '%s' to accept: " % accept_string) |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 150 | if answer != accept_string: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 151 | print("You did not type '%s'" % accept_string) |
| 152 | print('Aborting dev release for %s' % version) |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 153 | sys.exit(1) |
| 154 | |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 155 | |
| 156 | def maybe_check_call(args, cmd): |
| 157 | if args.dry_run: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 158 | print('DryRun:', ' '.join(cmd)) |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 159 | else: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 160 | print(' '.join(cmd)) |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 161 | return subprocess.check_call(cmd) |
| 162 | |
| 163 | |
Morten Krogh-Jespersen | d86a301 | 2020-02-21 15:06:13 +0100 | [diff] [blame] | 164 | def update_prebuilds(r8_checkout, version, checkout): |
| 165 | path = os.path.join(r8_checkout, 'tools', 'update_prebuilds_in_android.py') |
Ian Zerny | daf04ba | 2021-02-24 10:48:15 +0100 | [diff] [blame] | 166 | commit_arg = '--commit_hash=' if len(version) == 40 else '--version=' |
| 167 | subprocess.check_call([path, '--targets=lib', '--maps', commit_arg + version, checkout]) |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 168 | |
| 169 | |
Morten Krogh-Jespersen | d86a301 | 2020-02-21 15:06:13 +0100 | [diff] [blame] | 170 | def release_studio_or_aosp(r8_checkout, path, options, git_message): |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 171 | with utils.ChangedWorkingDirectory(path): |
Søren Gjesse | 5f90ec4 | 2019-12-02 16:03:51 +0100 | [diff] [blame] | 172 | if not options.use_existing_work_branch: |
| 173 | subprocess.call(['repo', 'abandon', 'update-r8']) |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 174 | if not options.no_sync: |
Ian Zerny | 25cccae | 2019-10-21 11:07:24 +0200 | [diff] [blame] | 175 | subprocess.check_call(['repo', 'sync', '-cq', '-j', '16']) |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 176 | |
| 177 | prebuilts_r8 = os.path.join(path, 'prebuilts', 'r8') |
| 178 | |
Søren Gjesse | 5f90ec4 | 2019-12-02 16:03:51 +0100 | [diff] [blame] | 179 | if not options.use_existing_work_branch: |
| 180 | with utils.ChangedWorkingDirectory(prebuilts_r8): |
| 181 | subprocess.check_call(['repo', 'start', 'update-r8']) |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 182 | |
Morten Krogh-Jespersen | d86a301 | 2020-02-21 15:06:13 +0100 | [diff] [blame] | 183 | update_prebuilds(r8_checkout, options.version, path) |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 184 | |
| 185 | with utils.ChangedWorkingDirectory(prebuilts_r8): |
Søren Gjesse | 5f90ec4 | 2019-12-02 16:03:51 +0100 | [diff] [blame] | 186 | if not options.use_existing_work_branch: |
| 187 | subprocess.check_call(['git', 'commit', '-a', '-m', git_message]) |
| 188 | else: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 189 | print('Not committing when --use-existing-work-branch. ' |
Søren Gjesse | 5f90ec4 | 2019-12-02 16:03:51 +0100 | [diff] [blame] | 190 | + 'Commit message should be:\n\n' |
| 191 | + git_message |
| 192 | + '\n') |
| 193 | # Don't upload if requested not to, or if changes are not committed due |
| 194 | # to --use-existing-work-branch |
| 195 | if not options.no_upload and not options.use_existing_work_branch: |
| 196 | process = subprocess.Popen(['repo', 'upload', '.', '--verify'], |
| 197 | stdin=subprocess.PIPE) |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 198 | return process.communicate(input=b'y\n')[0] |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 199 | |
| 200 | |
Morten Krogh-Jespersen | b4a7acc | 2019-10-02 10:46:32 +0200 | [diff] [blame] | 201 | def prepare_aosp(args): |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 202 | assert args.version |
Morten Krogh-Jespersen | 00db27f | 2019-10-02 16:14:46 +0200 | [diff] [blame] | 203 | assert os.path.exists(args.aosp), "Could not find AOSP path %s" % args.aosp |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 204 | |
| 205 | def release_aosp(options): |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 206 | print("Releasing for AOSP") |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 207 | if options.dry_run: |
| 208 | return 'DryRun: omitting AOSP release for %s' % options.version |
| 209 | |
Morten Krogh-Jespersen | b4a7acc | 2019-10-02 10:46:32 +0200 | [diff] [blame] | 210 | git_message = ("""Update D8 and R8 to %s |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 211 | |
Morten Krogh-Jespersen | dbbf9a8 | 2020-08-11 21:38:08 +0200 | [diff] [blame] | 212 | Version: %s |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 213 | This build IS NOT suitable for preview or public release. |
| 214 | |
Morten Krogh-Jespersen | b4a7acc | 2019-10-02 10:46:32 +0200 | [diff] [blame] | 215 | Built here: go/r8-releases/raw/%s |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 216 | |
| 217 | Test: TARGET_PRODUCT=aosp_arm64 m -j core-oj""" |
Morten Krogh-Jespersen | b4a7acc | 2019-10-02 10:46:32 +0200 | [diff] [blame] | 218 | % (args.version, args.version, args.version)) |
Morten Krogh-Jespersen | d86a301 | 2020-02-21 15:06:13 +0100 | [diff] [blame] | 219 | return release_studio_or_aosp( |
| 220 | utils.REPO_ROOT, args.aosp, options, git_message) |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 221 | |
| 222 | return release_aosp |
| 223 | |
| 224 | |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 225 | def prepare_maven(args): |
| 226 | assert args.version |
| 227 | |
| 228 | def release_maven(options): |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 229 | gfile = '/bigstore/r8-releases/raw/%s/r8lib.zip' % args.version |
| 230 | release_id = gmaven_publisher_stage(options, [gfile]) |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 231 | |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 232 | print("Staged Release ID " + release_id + ".\n") |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 233 | gmaven_publisher_stage_redir_test_info( |
| 234 | release_id, "com.android.tools:r8:%s" % args.version, "r8lib.jar") |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 235 | |
| 236 | print |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 237 | answer = input("Continue with publishing [y/N]:") |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 238 | |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 239 | if answer != 'y': |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 240 | print('Aborting release to Google maven') |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 241 | sys.exit(1) |
| 242 | |
| 243 | gmaven_publisher_publish(args, release_id) |
| 244 | |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 245 | print("") |
| 246 | print("Published. Use the email workflow for approval.") |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 247 | |
| 248 | return release_maven |
| 249 | |
Ian Zerny | acfaf29 | 2020-09-24 07:14:56 +0200 | [diff] [blame] | 250 | # ------------------------------------------------------ column 70 --v |
Ian Zerny | cf1eb3c | 2020-09-24 08:27:23 +0200 | [diff] [blame] | 251 | def git_message_dev(version, bugs): |
Morten Krogh-Jespersen | dbbf9a8 | 2020-08-11 21:38:08 +0200 | [diff] [blame] | 252 | return """Update D8 R8 to %s |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 253 | |
Ian Zerny | acfaf29 | 2020-09-24 07:14:56 +0200 | [diff] [blame] | 254 | This is a development snapshot, it's fine to use for studio canary |
| 255 | build, but not for BETA or release, for those we would need a release |
| 256 | version of R8 binaries. This build IS suitable for preview release |
| 257 | but IS NOT suitable for public release. |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 258 | |
Morten Krogh-Jespersen | b4a7acc | 2019-10-02 10:46:32 +0200 | [diff] [blame] | 259 | Built here: go/r8-releases/raw/%s |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 260 | Test: ./gradlew check |
Ian Zerny | fec0009 | 2022-03-16 08:25:07 +0100 | [diff] [blame] | 261 | Bug: %s""" % (version, version, '\nBug: '.join(map(bug_fmt, bugs))) |
Morten Krogh-Jespersen | b4a7acc | 2019-10-02 10:46:32 +0200 | [diff] [blame] | 262 | |
| 263 | |
Morten Krogh-Jespersen | a1396cd | 2019-10-02 16:14:40 +0200 | [diff] [blame] | 264 | def git_message_release(version, bugs): |
| 265 | return """D8 R8 version %s |
| 266 | |
| 267 | Built here: go/r8-releases/raw/%s/ |
| 268 | Test: ./gradlew check |
Morten Krogh-Jespersen | d86a301 | 2020-02-21 15:06:13 +0100 | [diff] [blame] | 269 | |
Ian Zerny | fec0009 | 2022-03-16 08:25:07 +0100 | [diff] [blame] | 270 | Bug: %s""" % (version, version, '\nBug: '.join(map(bug_fmt, bugs))) |
Morten Krogh-Jespersen | a1396cd | 2019-10-02 16:14:40 +0200 | [diff] [blame] | 271 | |
Ian Zerny | fec0009 | 2022-03-16 08:25:07 +0100 | [diff] [blame] | 272 | def bug_fmt(bug): |
| 273 | return "b/%s" % bug |
Morten Krogh-Jespersen | a1396cd | 2019-10-02 16:14:40 +0200 | [diff] [blame] | 274 | |
Morten Krogh-Jespersen | b4a7acc | 2019-10-02 10:46:32 +0200 | [diff] [blame] | 275 | def prepare_studio(args): |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 276 | assert args.version |
Morten Krogh-Jespersen | 00db27f | 2019-10-02 16:14:46 +0200 | [diff] [blame] | 277 | assert os.path.exists(args.studio), ("Could not find STUDIO path %s" |
| 278 | % args.studio) |
Morten Krogh-Jespersen | b4a7acc | 2019-10-02 10:46:32 +0200 | [diff] [blame] | 279 | |
| 280 | def release_studio(options): |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 281 | print("Releasing for STUDIO") |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 282 | if options.dry_run: |
| 283 | return 'DryRun: omitting studio release for %s' % options.version |
| 284 | |
Morten Krogh-Jespersen | d86a301 | 2020-02-21 15:06:13 +0100 | [diff] [blame] | 285 | if 'dev' in options.version: |
Ian Zerny | cf1eb3c | 2020-09-24 08:27:23 +0200 | [diff] [blame] | 286 | git_message = git_message_dev(options.version, options.bug) |
Morten Krogh-Jespersen | d86a301 | 2020-02-21 15:06:13 +0100 | [diff] [blame] | 287 | r8_checkout = utils.REPO_ROOT |
| 288 | return release_studio_or_aosp( |
| 289 | r8_checkout, args.studio, options, git_message) |
| 290 | else: |
| 291 | with utils.TempDir() as temp: |
| 292 | checkout_r8(temp, options.version[0:options.version.rindex('.')]) |
| 293 | git_message = git_message_release(options.version, options.bug) |
| 294 | return release_studio_or_aosp(temp, args.studio, options, git_message) |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 295 | |
| 296 | return release_studio |
| 297 | |
| 298 | |
| 299 | def g4_cp(old, new, file): |
| 300 | subprocess.check_call('g4 cp {%s,%s}/%s' % (old, new, file), shell=True) |
| 301 | |
| 302 | |
| 303 | def g4_open(file): |
Søren Gjesse | 0896766 | 2020-05-06 19:46:32 +0200 | [diff] [blame] | 304 | if not os.access(file, os.W_OK): |
| 305 | subprocess.check_call('g4 open %s' % file, shell=True) |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 306 | |
| 307 | |
Rico Wind | 8d008ca | 2020-04-22 12:13:15 +0200 | [diff] [blame] | 308 | def g4_change(version): |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 309 | return subprocess.check_output( |
Rico Wind | 8d008ca | 2020-04-22 12:13:15 +0200 | [diff] [blame] | 310 | 'g4 change --desc "Update R8 to version %s\n"' % (version), |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 311 | shell=True).decode('utf-8') |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 312 | |
Morten Krogh-Jespersen | 1f2f514 | 2020-09-21 11:20:23 +0200 | [diff] [blame] | 313 | def get_cl_id(c4_change_output): |
| 314 | startIndex = c4_change_output.find('Change ') + len('Change ') |
| 315 | endIndex = c4_change_output.find(' ', startIndex) |
| 316 | cl = c4_change_output[startIndex:endIndex] |
| 317 | assert cl.isdigit() |
| 318 | return cl |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 319 | |
| 320 | def sed(pattern, replace, path): |
| 321 | with open(path, "r") as sources: |
| 322 | lines = sources.readlines() |
| 323 | with open(path, "w") as sources: |
| 324 | for line in lines: |
| 325 | sources.write(re.sub(pattern, replace, line)) |
| 326 | |
| 327 | |
Morten Krogh-Jespersen | b4a7acc | 2019-10-02 10:46:32 +0200 | [diff] [blame] | 328 | def download_file(version, file, dst): |
Ian Zerny | 86c4cfd | 2022-01-17 13:43:37 +0100 | [diff] [blame] | 329 | dir = 'raw' if len(version) != 40 else 'raw/main' |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 330 | urllib.request.urlretrieve( |
Ian Zerny | 86c4cfd | 2022-01-17 13:43:37 +0100 | [diff] [blame] | 331 | ('https://storage.googleapis.com/r8-releases/%s/%s/%s' % (dir, version, file)), |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 332 | dst) |
| 333 | |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 334 | def download_gfile(gfile, dst): |
| 335 | if not gfile.startswith('/bigstore/r8-releases'): |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 336 | print('Unexpected gfile prefix for %s' % gfile) |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 337 | sys.exit(1) |
| 338 | |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 339 | urllib.request.urlretrieve( |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 340 | 'https://storage.googleapis.com/%s' % gfile[len('/bigstore/'):], |
| 341 | dst) |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 342 | |
| 343 | def blaze_run(target): |
| 344 | return subprocess.check_output( |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 345 | 'blaze run %s' % target, shell=True, stderr=subprocess.STDOUT).decode('utf-8') |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 346 | |
| 347 | |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 348 | def prepare_google3(args): |
| 349 | assert args.version |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 350 | # Check if an existing client exists. |
Søren Gjesse | 7e0ef85 | 2019-12-04 13:52:33 +0100 | [diff] [blame] | 351 | if not args.use_existing_work_branch: |
Søren Gjesse | 0896766 | 2020-05-06 19:46:32 +0200 | [diff] [blame] | 352 | check_no_google3_client(args, args.p4_client) |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 353 | |
| 354 | def release_google3(options): |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 355 | print("Releasing for Google 3") |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 356 | if options.dry_run: |
| 357 | return 'DryRun: omitting g3 release for %s' % options.version |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 358 | |
| 359 | google3_base = subprocess.check_output( |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 360 | ['p4', 'g4d', '-f', args.p4_client]).decode('utf-8').rstrip() |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 361 | third_party_r8 = os.path.join(google3_base, 'third_party', 'java', 'r8') |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 362 | today = datetime.date.today() |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 363 | with utils.ChangedWorkingDirectory(third_party_r8): |
Rico Wind | 8d008ca | 2020-04-22 12:13:15 +0200 | [diff] [blame] | 364 | # download files |
| 365 | g4_open('full.jar') |
| 366 | g4_open('src.jar') |
| 367 | g4_open('lib.jar') |
| 368 | g4_open('lib.jar.map') |
Morten Krogh-Jespersen | 0452794 | 2022-08-02 13:50:11 +0200 | [diff] [blame] | 369 | g4_open('retrace_full.jar') |
Morten Krogh-Jespersen | 98ee89a | 2021-10-25 20:59:02 +0200 | [diff] [blame] | 370 | g4_open('retrace_lib.jar') |
Morten Krogh-Jespersen | 0452794 | 2022-08-02 13:50:11 +0200 | [diff] [blame] | 371 | g4_open('retrace_lib.jar.map') |
Rico Wind | 369a21c | 2020-08-25 14:47:05 +0200 | [diff] [blame] | 372 | g4_open('desugar_jdk_libs_configuration.jar') |
Rico Wind | 8d008ca | 2020-04-22 12:13:15 +0200 | [diff] [blame] | 373 | download_file(options.version, 'r8-full-exclude-deps.jar', 'full.jar') |
Morten Krogh-Jespersen | 0452794 | 2022-08-02 13:50:11 +0200 | [diff] [blame] | 374 | download_file(options.version, 'r8-full-exclude-deps.jar', 'retrace_full.jar') |
Rico Wind | 8d008ca | 2020-04-22 12:13:15 +0200 | [diff] [blame] | 375 | download_file(options.version, 'r8-src.jar', 'src.jar') |
| 376 | download_file(options.version, 'r8lib-exclude-deps.jar', 'lib.jar') |
| 377 | download_file( |
| 378 | options.version, 'r8lib-exclude-deps.jar.map', 'lib.jar.map') |
Morten Krogh-Jespersen | 0452794 | 2022-08-02 13:50:11 +0200 | [diff] [blame] | 379 | download_file( |
| 380 | options.version, 'r8lib-exclude-deps.jar.map', 'retrace_lib.jar.map') |
Rico Wind | 369a21c | 2020-08-25 14:47:05 +0200 | [diff] [blame] | 381 | download_file(options.version, 'desugar_jdk_libs_configuration.jar', |
| 382 | 'desugar_jdk_libs_configuration.jar') |
Morten Krogh-Jespersen | 98ee89a | 2021-10-25 20:59:02 +0200 | [diff] [blame] | 383 | download_file(options.version, 'r8retrace-exclude-deps.jar', 'retrace_lib.jar') |
Rico Wind | 8d008ca | 2020-04-22 12:13:15 +0200 | [diff] [blame] | 384 | g4_open('METADATA') |
Søren Gjesse | e4f90c6 | 2022-06-27 12:47:45 +0200 | [diff] [blame] | 385 | metadata_path = os.path.join(third_party_r8, 'METADATA') |
| 386 | match_count = 0 |
| 387 | version_match_regexp = r'[1-9]\.[0-9]{1,2}\.[0-9]{1,3}-dev' |
| 388 | for line in open(metadata_path, 'r'): |
| 389 | result = re.search(version_match_regexp, line) |
| 390 | if result: |
| 391 | match_count = match_count + 1 |
Rico Wind | d05a7a7 | 2022-08-09 13:11:10 +0200 | [diff] [blame] | 392 | if match_count != 4: |
Søren Gjesse | e4f90c6 | 2022-06-27 12:47:45 +0200 | [diff] [blame] | 393 | print(("Could not find the previous -dev release string to replace in " + |
Rico Wind | d05a7a7 | 2022-08-09 13:11:10 +0200 | [diff] [blame] | 394 | "METADATA. Expected to find is mentioned 4 times. Please update %s " + |
Ian Zerny | 69fbfb8 | 2022-08-04 12:44:17 +0200 | [diff] [blame] | 395 | "manually and run again with options --google3 " + |
Søren Gjesse | e4f90c6 | 2022-06-27 12:47:45 +0200 | [diff] [blame] | 396 | "--use-existing-work-branch.") % metadata_path) |
| 397 | sys.exit(1) |
| 398 | sed(version_match_regexp, options.version, metadata_path) |
Rico Wind | 8d008ca | 2020-04-22 12:13:15 +0200 | [diff] [blame] | 399 | sed(r'\{ year.*\}', |
| 400 | ('{ year: %i month: %i day: %i }' |
| 401 | % (today.year, today.month, today.day)), |
Søren Gjesse | e4f90c6 | 2022-06-27 12:47:45 +0200 | [diff] [blame] | 402 | metadata_path) |
Rico Wind | 8d008ca | 2020-04-22 12:13:15 +0200 | [diff] [blame] | 403 | subprocess.check_output('chmod u+w *', shell=True) |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 404 | |
| 405 | with utils.ChangedWorkingDirectory(google3_base): |
| 406 | blaze_result = blaze_run('//third_party/java/r8:d8 -- --version') |
| 407 | |
| 408 | assert options.version in blaze_result |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 409 | |
Søren Gjesse | 5f90ec4 | 2019-12-02 16:03:51 +0100 | [diff] [blame] | 410 | if not options.no_upload: |
Morten Krogh-Jespersen | 1f2f514 | 2020-09-21 11:20:23 +0200 | [diff] [blame] | 411 | change_result = g4_change(options.version) |
| 412 | change_result += 'Run \'(g4d ' + args.p4_client \ |
| 413 | + ' && tap_presubmit -p all --train -c ' \ |
Søren Gjesse | 8a5f3df | 2021-06-09 14:48:40 +0200 | [diff] [blame] | 414 | + get_cl_id(change_result) + ')\' for running TAP global' \ |
| 415 | + ' presubmit using the train.\n' \ |
| 416 | + 'Run \'(g4d ' + args.p4_client \ |
| 417 | + ' && tap_presubmit -p all --notrain --detach --email' \ |
| 418 | + ' --skip_flaky_targets --skip_already_failing -c ' \ |
| 419 | + get_cl_id(change_result) + ')\' for running an isolated' \ |
| 420 | + ' TAP global presubmit.' |
Morten Krogh-Jespersen | 1f2f514 | 2020-09-21 11:20:23 +0200 | [diff] [blame] | 421 | return change_result |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 422 | |
| 423 | return release_google3 |
| 424 | |
| 425 | |
Morten Krogh-Jespersen | 0452794 | 2022-08-02 13:50:11 +0200 | [diff] [blame] | 426 | def prepare_google3_retrace(args): |
| 427 | assert args.version |
| 428 | # Check if an existing client exists. |
| 429 | if not args.use_existing_work_branch: |
| 430 | check_no_google3_client(args, args.p4_client) |
| 431 | |
| 432 | def release_google3_retrace(options): |
| 433 | print("Releasing Retrace for Google 3") |
| 434 | if options.dry_run: |
| 435 | return 'DryRun: omitting g3 release for %s' % options.version |
| 436 | |
| 437 | google3_base = subprocess.check_output( |
| 438 | ['p4', 'g4d', '-f', args.p4_client]).decode('utf-8').rstrip() |
| 439 | third_party_r8 = os.path.join(google3_base, 'third_party', 'java', 'r8') |
| 440 | with utils.ChangedWorkingDirectory(third_party_r8): |
| 441 | # download files |
| 442 | g4_open('retrace_full.jar') |
| 443 | g4_open('retrace_lib.jar') |
| 444 | g4_open('retrace_lib.jar.map') |
| 445 | download_file(options.version, 'r8-full-exclude-deps.jar', 'retrace_full.jar') |
| 446 | download_file(options.version, 'r8retrace-exclude-deps.jar', 'retrace_lib.jar') |
| 447 | download_file( |
| 448 | options.version, 'r8lib-exclude-deps.jar.map', 'retrace_lib.jar.map') |
| 449 | g4_open('METADATA') |
| 450 | metadata_path = os.path.join(third_party_r8, 'METADATA') |
| 451 | match_count = 0 |
| 452 | version_match_regexp = r'[1-9]\.[0-9]{1,2}\.[0-9]{1,3}-dev/r8retrace-exclude-deps.jar' |
| 453 | for line in open(metadata_path, 'r'): |
| 454 | result = re.search(version_match_regexp, line) |
| 455 | if result: |
| 456 | match_count = match_count + 1 |
| 457 | if match_count != 1: |
| 458 | print(("Could not find the previous retrace release string to replace in " + |
| 459 | "METADATA. Expected to find is mentioned 1 times. Please update %s " + |
| 460 | "manually and run again with options --google3retrace " + |
| 461 | "--use-existing-work-branch.") % metadata_path) |
| 462 | sys.exit(1) |
| 463 | sed(version_match_regexp, options.version + "/r8retrace-exclude-deps.jar", metadata_path) |
| 464 | subprocess.check_output('chmod u+w *', shell=True) |
| 465 | |
| 466 | with utils.ChangedWorkingDirectory(google3_base): |
| 467 | blaze_result = blaze_run('//third_party/java/r8:retrace -- --version') |
| 468 | |
| 469 | print(blaze_result) |
| 470 | assert options.version in blaze_result |
| 471 | |
| 472 | if not options.no_upload: |
| 473 | change_result = g4_change(options.version) |
| 474 | change_result += 'Run \'(g4d ' + args.p4_client \ |
| 475 | + ' && tap_presubmit -p all --train -c ' \ |
| 476 | + get_cl_id(change_result) + ')\' for running TAP global' \ |
| 477 | + ' presubmit using the train.\n' \ |
| 478 | + 'Run \'(g4d ' + args.p4_client \ |
| 479 | + ' && tap_presubmit -p all --notrain --detach --email' \ |
| 480 | + ' --skip_flaky_targets --skip_already_failing -c ' \ |
| 481 | + get_cl_id(change_result) + ')\' for running an isolated' \ |
| 482 | + ' TAP global presubmit.' |
| 483 | return change_result |
| 484 | |
| 485 | return release_google3_retrace |
| 486 | |
Søren Gjesse | 73355ec | 2020-06-29 09:19:44 +0200 | [diff] [blame] | 487 | def update_desugar_library_in_studio(args): |
| 488 | assert os.path.exists(args.studio), ("Could not find STUDIO path %s" |
| 489 | % args.studio) |
| 490 | |
| 491 | def make_release(args): |
| 492 | library_version = args.update_desugar_library_in_studio[0] |
| 493 | configuration_version = args.update_desugar_library_in_studio[1] |
| 494 | change_name = 'update-desugar-library-dependencies' |
| 495 | |
| 496 | with utils.ChangedWorkingDirectory(args.studio): |
| 497 | if not args.use_existing_work_branch: |
| 498 | subprocess.call(['repo', 'abandon', change_name]) |
| 499 | if not args.no_sync: |
| 500 | subprocess.check_call(['repo', 'sync', '-cq', '-j', '16']) |
| 501 | |
| 502 | cmd = ['tools/base/bazel/bazel', |
| 503 | 'run', |
| 504 | '//tools/base/bazel:add_dependency', |
| 505 | '--', |
| 506 | '--repo=https://maven.google.com com.android.tools:desugar_jdk_libs:%s' % library_version] |
| 507 | utils.PrintCmd(cmd) |
| 508 | subprocess.check_call(" ".join(cmd), shell=True) |
| 509 | cmd = ['tools/base/bazel/bazel', 'shutdown'] |
| 510 | utils.PrintCmd(cmd) |
| 511 | subprocess.check_call(cmd) |
| 512 | |
| 513 | prebuilts_tools = os.path.join(args.studio, 'prebuilts', 'tools') |
| 514 | with utils.ChangedWorkingDirectory(prebuilts_tools): |
| 515 | if not args.use_existing_work_branch: |
| 516 | with utils.ChangedWorkingDirectory(prebuilts_tools): |
| 517 | subprocess.check_call(['repo', 'start', change_name]) |
| 518 | m2_dir = os.path.join( |
| 519 | 'common', 'm2', 'repository', 'com', 'android', 'tools') |
| 520 | subprocess.check_call( |
| 521 | ['git', |
| 522 | 'add', |
| 523 | os.path.join(m2_dir, DESUGAR_JDK_LIBS, library_version)]) |
| 524 | subprocess.check_call( |
| 525 | ['git', |
| 526 | 'add', |
| 527 | os.path.join( |
| 528 | m2_dir, DESUGAR_JDK_LIBS_CONFIGURATION, configuration_version)]) |
| 529 | |
| 530 | git_message = ("""Update library desugaring dependencies |
| 531 | |
| 532 | com.android.tools:desugar_jdk_libs:%s |
| 533 | com.android.tools:desugar_jdk_libs_configuration:%s |
| 534 | |
| 535 | Bug: %s |
| 536 | Test: L8ToolTest, L8DexDesugarTest""" |
| 537 | % (library_version, |
| 538 | configuration_version, |
Ian Zerny | fec0009 | 2022-03-16 08:25:07 +0100 | [diff] [blame] | 539 | '\nBug: '.join(map(bug_fmt, args.bug)))) |
Søren Gjesse | 73355ec | 2020-06-29 09:19:44 +0200 | [diff] [blame] | 540 | |
| 541 | if not args.use_existing_work_branch: |
| 542 | subprocess.check_call(['git', 'commit', '-a', '-m', git_message]) |
| 543 | else: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 544 | print('Not committing when --use-existing-work-branch. ' |
Søren Gjesse | 73355ec | 2020-06-29 09:19:44 +0200 | [diff] [blame] | 545 | + 'Commit message should be:\n\n' |
| 546 | + git_message |
| 547 | + '\n') |
| 548 | # Don't upload if requested not to, or if changes are not committed due |
| 549 | # to --use-existing-work-branch |
| 550 | if not args.no_upload and not args.use_existing_work_branch: |
| 551 | process = subprocess.Popen(['repo', 'upload', '.', '--verify'], |
| 552 | stdin=subprocess.PIPE) |
| 553 | return process.communicate(input='y\n')[0] |
| 554 | |
| 555 | return make_release |
| 556 | |
| 557 | |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 558 | def prepare_desugar_library(args): |
| 559 | |
| 560 | def make_release(args): |
| 561 | library_version = args.desugar_library[0] |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 562 | configuration_version = args.desugar_library[1] |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 563 | |
Søren Gjesse | e78b165 | 2022-06-30 12:38:36 +0200 | [diff] [blame] | 564 | # TODO(b/237636871): Cleanup and generalize. |
| 565 | if (not (library_version.startswith('1.1') or library_version.startswith('1.2'))): |
| 566 | print("Release script does not support desugared library version %s" |
| 567 | % library_version) |
| 568 | sys.exit(1) |
| 569 | |
Søren Gjesse | e78b165 | 2022-06-30 12:38:36 +0200 | [diff] [blame] | 570 | postfix = "" if library_version.startswith('1.1') else '_jdk11_legacy' |
Søren Gjesse | f637d9d | 2022-08-24 15:32:55 +0200 | [diff] [blame] | 571 | library_archive = DESUGAR_JDK_LIBS + postfix + '.zip' |
| 572 | library_jar = DESUGAR_JDK_LIBS + postfix + '.jar' |
| 573 | |
Søren Gjesse | e78b165 | 2022-06-30 12:38:36 +0200 | [diff] [blame] | 574 | configuration_archive = DESUGAR_JDK_LIBS_CONFIGURATION + postfix + '.zip' |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 575 | |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 576 | with utils.TempDir() as temp: |
| 577 | with utils.ChangedWorkingDirectory(temp): |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 578 | library_gfile = ('/bigstore/r8-releases/raw/%s/%s/%s' |
| 579 | % (DESUGAR_JDK_LIBS, library_version, library_archive)) |
Rico Wind | 1b52acf | 2021-03-21 12:36:55 +0100 | [diff] [blame] | 580 | configuration_gfile = ('/bigstore/r8-releases/raw/main/%s/%s' |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 581 | % (configuration_version, configuration_archive)) |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 582 | |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 583 | download_gfile(library_gfile, library_archive) |
| 584 | download_gfile(configuration_gfile, configuration_archive) |
| 585 | check_configuration(configuration_archive) |
| 586 | |
| 587 | release_id = gmaven_publisher_stage( |
| 588 | args, [library_gfile, configuration_gfile]) |
| 589 | |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 590 | print("Staged Release ID " + release_id + ".\n") |
Søren Gjesse | f637d9d | 2022-08-24 15:32:55 +0200 | [diff] [blame] | 591 | library_artifact_id = \ |
| 592 | '%s:%s:%s' % (ANDROID_TOOLS_PACKAGE, DESUGAR_JDK_LIBS, library_version) |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 593 | gmaven_publisher_stage_redir_test_info( |
| 594 | release_id, |
Søren Gjesse | f637d9d | 2022-08-24 15:32:55 +0200 | [diff] [blame] | 595 | library_artifact_id, |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 596 | library_jar) |
| 597 | |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 598 | print("") |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 599 | answer = input("Continue with publishing [y/N]:") |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 600 | |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 601 | if answer != 'y': |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 602 | print('Aborting release to Google maven') |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 603 | sys.exit(1) |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 604 | |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 605 | gmaven_publisher_publish(args, release_id) |
| 606 | |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 607 | print("") |
| 608 | print("Published. Use the email workflow for approval.") |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 609 | |
| 610 | return make_release |
| 611 | |
| 612 | |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 613 | def check_configuration(configuration_archive): |
| 614 | zip = zipfile.ZipFile(configuration_archive) |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 615 | zip.extractall() |
| 616 | dirs = os.listdir( |
| 617 | os.path.join('com', 'android', 'tools', DESUGAR_JDK_LIBS_CONFIGURATION)) |
| 618 | if len(dirs) != 1: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 619 | print('Unexpected archive content, %s' + dirs) |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 620 | sys.exit(1) |
| 621 | |
| 622 | version = dirs[0] |
| 623 | pom_file = os.path.join( |
| 624 | 'com', |
| 625 | 'android', |
| 626 | 'tools', |
| 627 | DESUGAR_JDK_LIBS_CONFIGURATION, |
| 628 | version, |
| 629 | '%s-%s.pom' % (DESUGAR_JDK_LIBS_CONFIGURATION, version)) |
| 630 | version_from_pom = extract_version_from_pom(pom_file) |
| 631 | if version != version_from_pom: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 632 | print('Version mismatch, %s != %s' % (version, version_from_pom)) |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 633 | sys.exit(1) |
Søren Gjesse | 07b6aea | 2019-12-12 11:11:58 +0100 | [diff] [blame] | 634 | |
| 635 | def check_no_google3_client(args, client_name): |
| 636 | if not args.use_existing_work_branch: |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 637 | clients = subprocess.check_output('g4 myclients', shell=True).decode('utf-8') |
Søren Gjesse | 07b6aea | 2019-12-12 11:11:58 +0100 | [diff] [blame] | 638 | if ':%s:' % client_name in clients: |
Søren Gjesse | e4f90c6 | 2022-06-27 12:47:45 +0200 | [diff] [blame] | 639 | if args.delete_work_branch: |
| 640 | subprocess.check_call('g4 citc -d -f %s' % client_name, shell=True) |
| 641 | else: |
| 642 | print(("Remove the existing '%s' client before continuing " + |
| 643 | "(force delete: 'g4 citc -d -f %s'), " + |
| 644 | "or use either --use-existing-work-branch or " + |
| 645 | "--delete-work-branch.") % (client_name, client_name)) |
| 646 | sys.exit(1) |
Søren Gjesse | 07b6aea | 2019-12-12 11:11:58 +0100 | [diff] [blame] | 647 | |
| 648 | |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 649 | def extract_version_from_pom(pom_file): |
| 650 | ns = "http://maven.apache.org/POM/4.0.0" |
| 651 | xml.etree.ElementTree.register_namespace('', ns) |
| 652 | tree = xml.etree.ElementTree.ElementTree() |
| 653 | tree.parse(pom_file) |
| 654 | return tree.getroot().find("{%s}version" % ns).text |
| 655 | |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 656 | |
| 657 | GMAVEN_PUBLISH_STAGE_RELEASE_ID_PATTERN = re.compile('Release ID = ([0-9a-f\-]+)') |
| 658 | |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 659 | |
| 660 | def gmaven_publisher_stage(args, gfiles): |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 661 | if args.dry_run: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 662 | print('Dry-run, would have staged %s' % gfiles) |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 663 | return 'dry-run-release-id' |
| 664 | |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 665 | print("Staging: %s" % ', '.join(gfiles)) |
| 666 | print("") |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 667 | |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 668 | cmd = [GMAVEN_PUBLISHER, 'stage', '--gfile', ','.join(gfiles)] |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 669 | output = subprocess.check_output(cmd) |
| 670 | |
| 671 | # Expect output to contain: |
| 672 | # [INFO] 06/19/2020 09:35:12 CEST: >>>>>>>>>> Staged |
| 673 | # [INFO] 06/19/2020 09:35:12 CEST: Release ID = 9171d015-18f6-4a90-9984-1c362589dc1b |
| 674 | # [INFO] 06/19/2020 09:35:12 CEST: Stage Path = /bigstore/studio_staging/maven2/sgjesse/9171d015-18f6-4a90-9984-1c362589dc1b |
| 675 | |
Søren Gjesse | 7b15111 | 2021-02-16 14:32:32 +0100 | [diff] [blame] | 676 | matches = GMAVEN_PUBLISH_STAGE_RELEASE_ID_PATTERN.findall(output.decode("utf-8")) |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 677 | if matches == None or len(matches) > 1: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 678 | print("Could not determine the release ID from the gmaven_publisher " + |
| 679 | "output. Expected a line with 'Release ID = <release id>'.") |
| 680 | print("Output was:") |
| 681 | print(output) |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 682 | sys.exit(1) |
| 683 | |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 684 | print(output) |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 685 | |
| 686 | release_id = matches[0] |
| 687 | return release_id |
| 688 | |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 689 | |
| 690 | def gmaven_publisher_stage_redir_test_info(release_id, artifact, dst): |
| 691 | |
| 692 | redir_command = ("/google/data/ro/teams/android-devtools-infra/tools/redir " |
| 693 | + "--alsologtostderr " |
Søren Gjesse | 44eee51 | 2021-09-24 11:44:11 +0200 | [diff] [blame] | 694 | + "--gcs_bucket_path=/bigstore/gmaven-staging/${USER}/%s " |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 695 | + "--port=1480") % release_id |
| 696 | |
| 697 | get_command = ("mvn org.apache.maven.plugins:maven-dependency-plugin:2.4:get " |
| 698 | + "-Dmaven.repo.local=/tmp/maven_repo_local " |
| 699 | + "-DremoteRepositories=http://localhost:1480 " |
| 700 | + "-Dartifact=%s " |
| 701 | + "-Ddest=%s") % (artifact, dst) |
| 702 | |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 703 | print("""To test the staged content with 'redir' run: |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 704 | |
| 705 | %s |
| 706 | |
Søren Gjesse | e78b165 | 2022-06-30 12:38:36 +0200 | [diff] [blame] | 707 | Then add the following repository to settings.gradle to search the 'redir' |
| 708 | repository: |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 709 | |
Søren Gjesse | e78b165 | 2022-06-30 12:38:36 +0200 | [diff] [blame] | 710 | dependencyResolutionManagement { |
| 711 | repositories { |
| 712 | maven { |
| 713 | url 'http://localhost:1480' |
| 714 | allowInsecureProtocol true |
| 715 | } |
Søren Gjesse | 44eee51 | 2021-09-24 11:44:11 +0200 | [diff] [blame] | 716 | } |
Søren Gjesse | e78b165 | 2022-06-30 12:38:36 +0200 | [diff] [blame] | 717 | } |
| 718 | |
| 719 | and add the following repository to gradle.build for for the staged version: |
| 720 | |
| 721 | dependencies { |
| 722 | coreLibraryDesugaring('%s') { |
| 723 | changing = true |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 724 | } |
| 725 | } |
| 726 | |
| 727 | Use this commands to get artifact from 'redir': |
| 728 | |
| 729 | rm -rf /tmp/maven_repo_local |
| 730 | %s |
Søren Gjesse | 44eee51 | 2021-09-24 11:44:11 +0200 | [diff] [blame] | 731 | """ % (redir_command, artifact, get_command)) |
Søren Gjesse | b093b67 | 2020-06-23 16:23:10 +0200 | [diff] [blame] | 732 | |
| 733 | |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 734 | def gmaven_publisher_publish(args, release_id): |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 735 | if args.dry_run: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 736 | print('Dry-run, would have published %s' % release_id) |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 737 | return |
| 738 | |
| 739 | cmd = [GMAVEN_PUBLISHER, 'publish', release_id] |
| 740 | output = subprocess.check_output(cmd) |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 741 | |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 742 | def branch_change_diff(diff, old_version, new_version): |
| 743 | invalid_line = None |
Søren Gjesse | 25ef552 | 2021-05-05 08:17:00 +0200 | [diff] [blame] | 744 | for line in str(diff).splitlines(): |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 745 | if line.startswith('-R8') and \ |
| 746 | line != "-R8_DEV_BRANCH = '%s'" % old_version: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 747 | print(line) |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 748 | invalid_line = line |
| 749 | elif line.startswith('+R8') and \ |
| 750 | line != "+R8_DEV_BRANCH = '%s'" % new_version: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 751 | print(line) |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 752 | invalid_line = line |
| 753 | return invalid_line |
| 754 | |
| 755 | |
| 756 | def validate_branch_change_diff(version_diff_output, old_version, new_version): |
| 757 | invalid = branch_change_diff(version_diff_output, old_version, new_version) |
| 758 | if invalid: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 759 | print("") |
| 760 | print("The diff for the branch change in tools/release.py is not as expected:") |
| 761 | print("") |
| 762 | print("=" * 80) |
| 763 | print(version_diff_output) |
| 764 | print("=" * 80) |
| 765 | print("") |
| 766 | print("Validate the uploaded CL before landing.") |
| 767 | print("") |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 768 | |
| 769 | |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 770 | def prepare_branch(args): |
| 771 | branch_version = args.new_dev_branch[0] |
| 772 | commithash = args.new_dev_branch[1] |
| 773 | |
| 774 | current_semver = utils.check_basic_semver_version( |
| 775 | R8_DEV_BRANCH, ", current release branch version should be x.y", 2) |
| 776 | semver = utils.check_basic_semver_version( |
| 777 | branch_version, ", release branch version should be x.y", 2) |
| 778 | if not semver.larger_than(current_semver): |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 779 | print('New branch version "' |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 780 | + branch_version |
| 781 | + '" must be strictly larger than the current "' |
| 782 | + R8_DEV_BRANCH |
| 783 | + '"') |
| 784 | sys.exit(1) |
| 785 | |
| 786 | def make_branch(options): |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 787 | with utils.TempDir() as temp: |
| 788 | subprocess.check_call(['git', 'clone', utils.REPO_SOURCE, temp]) |
| 789 | with utils.ChangedWorkingDirectory(temp): |
| 790 | subprocess.check_call(['git', 'branch', branch_version, commithash]) |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 791 | |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 792 | subprocess.check_call(['git', 'checkout', branch_version]) |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 793 | |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 794 | # Rewrite the version, commit and validate. |
Rico Wind | 1b52acf | 2021-03-21 12:36:55 +0100 | [diff] [blame] | 795 | old_version = 'main' |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 796 | full_version = branch_version + '.0-dev' |
| 797 | version_prefix = 'LABEL = "' |
| 798 | sed(version_prefix + old_version, |
| 799 | version_prefix + full_version, |
| 800 | R8_VERSION_FILE) |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 801 | |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 802 | subprocess.check_call([ |
| 803 | 'git', 'commit', '-a', '-m', 'Version %s' % full_version]) |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 804 | |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 805 | version_diff_output = subprocess.check_output([ |
| 806 | 'git', 'diff', '%s..HEAD' % commithash]) |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 807 | |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 808 | validate_version_change_diff(version_diff_output, old_version, full_version) |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 809 | |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 810 | # Double check that we want to create a new release branch. |
| 811 | if not options.dry_run: |
Christoffer Quist Adamsen | d408d8d | 2021-01-26 19:50:39 +0100 | [diff] [blame] | 812 | answer = input('Create new branch for %s [y/N]:' % branch_version) |
| 813 | if answer != 'y': |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 814 | print('Aborting new branch for %s' % branch_version) |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 815 | sys.exit(1) |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 816 | |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 817 | maybe_check_call(options, [ |
| 818 | 'git', 'push', 'origin', 'HEAD:%s' % branch_version]) |
| 819 | maybe_tag(options, full_version) |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 820 | |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 821 | print('Updating tools/r8_release.py to make new dev releases on %s' |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 822 | % branch_version) |
| 823 | |
| 824 | subprocess.check_call(['git', 'new-branch', 'update-release-script']) |
| 825 | |
| 826 | # Check this file for the setting of the current dev branch. |
| 827 | result = None |
Søren Gjesse | 2725159 | 2019-11-06 17:35:23 +0100 | [diff] [blame] | 828 | for line in open(THIS_FILE_RELATIVE, 'r'): |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 829 | result = re.match( |
| 830 | r"^R8_DEV_BRANCH = '(\d+).(\d+)'", line) |
| 831 | if result: |
| 832 | break |
| 833 | if not result or not result.group(1): |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 834 | print('Failed to find version label in %s' % THIS_FILE_RELATIVE) |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 835 | sys.exit(1) |
| 836 | |
| 837 | # Update this file with the new dev branch. |
| 838 | sed("R8_DEV_BRANCH = '%s.%s" % (result.group(1), result.group(2)), |
| 839 | "R8_DEV_BRANCH = '%s.%s" % (str(semver.major), str(semver.minor)), |
Søren Gjesse | 2725159 | 2019-11-06 17:35:23 +0100 | [diff] [blame] | 840 | THIS_FILE_RELATIVE) |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 841 | |
Søren Gjesse | 2725159 | 2019-11-06 17:35:23 +0100 | [diff] [blame] | 842 | message = \ |
| 843 | 'Prepare %s for branch %s' % (THIS_FILE_RELATIVE, branch_version) |
Søren Gjesse | ddeb02e | 2019-11-06 15:48:07 +0100 | [diff] [blame] | 844 | subprocess.check_call(['git', 'commit', '-a', '-m', message]) |
| 845 | |
| 846 | branch_diff_output = subprocess.check_output(['git', 'diff', 'HEAD~']) |
| 847 | |
| 848 | validate_branch_change_diff( |
| 849 | branch_diff_output, R8_DEV_BRANCH, branch_version) |
| 850 | |
| 851 | maybe_check_call(options, ['git', 'cl', 'upload', '-f', '-m', message]) |
| 852 | |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 853 | print('') |
| 854 | print('Make sure to send out the branch change CL for review.') |
| 855 | print('') |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 856 | |
| 857 | return make_branch |
| 858 | |
| 859 | |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 860 | def parse_options(): |
| 861 | result = argparse.ArgumentParser(description='Release r8') |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 862 | group = result.add_mutually_exclusive_group() |
| 863 | group.add_argument('--dev-release', |
Rico Wind | 1b52acf | 2021-03-21 12:36:55 +0100 | [diff] [blame] | 864 | metavar=('<main hash>'), |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 865 | help='The hash to use for the new dev version of R8') |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 866 | group.add_argument('--version', |
| 867 | metavar=('<version>'), |
| 868 | help='The new version of R8 (e.g., 1.4.51) to release to selected channels') |
| 869 | group.add_argument('--desugar-library', |
| 870 | nargs=2, |
| 871 | metavar=('<version>', '<configuration hash>'), |
| 872 | help='The new version of com.android.tools:desugar_jdk_libs') |
Søren Gjesse | 73355ec | 2020-06-29 09:19:44 +0200 | [diff] [blame] | 873 | group.add_argument('--update-desugar-library-in-studio', |
| 874 | nargs=2, |
| 875 | metavar=('<version>', '<configuration version>'), |
| 876 | help='Update studio mirror of com.android.tools:desugar_jdk_libs') |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 877 | group.add_argument('--new-dev-branch', |
| 878 | nargs=2, |
Rico Wind | 1b52acf | 2021-03-21 12:36:55 +0100 | [diff] [blame] | 879 | metavar=('<version>', '<main hash>'), |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 880 | help='Create a new branch starting a version line (e.g. 2.0)') |
Rico Wind | 140a564 | 2019-11-26 10:44:21 +0100 | [diff] [blame] | 881 | result.add_argument('--dev-pre-cherry-pick', |
Rico Wind | 1b52acf | 2021-03-21 12:36:55 +0100 | [diff] [blame] | 882 | metavar=('<main hash(s)>'), |
Rico Wind | 140a564 | 2019-11-26 10:44:21 +0100 | [diff] [blame] | 883 | default=[], |
| 884 | action='append', |
| 885 | help='List of commits to cherry pick before doing full ' |
| 886 | 'merge, mostly used for reverting cherry picks') |
Søren Gjesse | b8dec61 | 2019-10-10 09:15:43 +0200 | [diff] [blame] | 887 | result.add_argument('--no-sync', '--no_sync', |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 888 | default=False, |
| 889 | action='store_true', |
| 890 | help='Do not sync repos before uploading') |
Morten Krogh-Jespersen | a1396cd | 2019-10-02 16:14:40 +0200 | [diff] [blame] | 891 | result.add_argument('--bug', |
Søren Gjesse | 53539ae | 2019-11-06 09:47:01 +0100 | [diff] [blame] | 892 | metavar=('<bug(s)>'), |
Morten Krogh-Jespersen | a1396cd | 2019-10-02 16:14:40 +0200 | [diff] [blame] | 893 | default=[], |
| 894 | action='append', |
| 895 | help='List of bugs for release version') |
Søren Gjesse | 5aa4a68 | 2022-08-26 09:17:27 +0200 | [diff] [blame] | 896 | result.add_argument('--no-bugs', |
| 897 | default=False, |
| 898 | action='store_true', |
| 899 | help='Allow Studio release without specifying any bugs') |
Morten Krogh-Jespersen | 00db27f | 2019-10-02 16:14:46 +0200 | [diff] [blame] | 900 | result.add_argument('--studio', |
Søren Gjesse | 53539ae | 2019-11-06 09:47:01 +0100 | [diff] [blame] | 901 | metavar=('<path>'), |
Morten Krogh-Jespersen | 00db27f | 2019-10-02 16:14:46 +0200 | [diff] [blame] | 902 | help='Release for studio by setting the path to a studio ' |
| 903 | 'checkout') |
| 904 | result.add_argument('--aosp', |
Søren Gjesse | 53539ae | 2019-11-06 09:47:01 +0100 | [diff] [blame] | 905 | metavar=('<path>'), |
Morten Krogh-Jespersen | 00db27f | 2019-10-02 16:14:46 +0200 | [diff] [blame] | 906 | help='Release for aosp by setting the path to the ' |
| 907 | 'checkout') |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 908 | result.add_argument('--maven', |
| 909 | default=False, |
| 910 | action='store_true', |
| 911 | help='Release to Google Maven') |
Morten Krogh-Jespersen | 00db27f | 2019-10-02 16:14:46 +0200 | [diff] [blame] | 912 | result.add_argument('--google3', |
| 913 | default=False, |
| 914 | action='store_true', |
| 915 | help='Release for google 3') |
Morten Krogh-Jespersen | 0452794 | 2022-08-02 13:50:11 +0200 | [diff] [blame] | 916 | result.add_argument('--google3retrace', |
| 917 | default=False, |
| 918 | action='store_true', |
| 919 | help='Release retrace for google 3') |
Søren Gjesse | 0896766 | 2020-05-06 19:46:32 +0200 | [diff] [blame] | 920 | result.add_argument('--p4-client', |
| 921 | default='update-r8', |
| 922 | metavar=('<client name>'), |
| 923 | help='P4 client name for google 3') |
Søren Gjesse | 5f90ec4 | 2019-12-02 16:03:51 +0100 | [diff] [blame] | 924 | result.add_argument('--use-existing-work-branch', '--use_existing_work_branch', |
| 925 | default=False, |
| 926 | action='store_true', |
| 927 | help='Use existing work branch/CL in aosp/studio/google3') |
Søren Gjesse | e4f90c6 | 2022-06-27 12:47:45 +0200 | [diff] [blame] | 928 | result.add_argument('--delete-work-branch', '--delete_work_branch', |
| 929 | default=False, |
| 930 | action='store_true', |
| 931 | help='Delete CL in google3') |
Søren Gjesse | 5f90ec4 | 2019-12-02 16:03:51 +0100 | [diff] [blame] | 932 | result.add_argument('--no-upload', '--no_upload', |
| 933 | default=False, |
| 934 | action='store_true', |
| 935 | help="Don't upload for code review") |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 936 | result.add_argument('--dry-run', |
| 937 | default=False, |
| 938 | action='store_true', |
| 939 | help='Only perform non-commiting tasks and print others.') |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 940 | result.add_argument('--dry-run-output', '--dry_run_output', |
| 941 | default=os.getcwd(), |
| 942 | metavar=('<path>'), |
| 943 | help='Location for dry run output.') |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 944 | args = result.parse_args() |
Søren Gjesse | 5aa4a68 | 2022-08-26 09:17:27 +0200 | [diff] [blame] | 945 | if (len(args.bug) > 0 and args.no_bugs): |
| 946 | print("Use of '--bug' and '--no-bugs' are mutually exclusive") |
| 947 | sys.exit(1) |
| 948 | |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 949 | if (args.studio |
| 950 | and args.version |
| 951 | and not 'dev' in args.version |
Søren Gjesse | 5aa4a68 | 2022-08-26 09:17:27 +0200 | [diff] [blame] | 952 | and args.bug == [] |
| 953 | and not args.no_bugs): |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 954 | print("When releasing a release version to Android Studio add the " |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 955 | + "list of bugs by using '--bug'") |
Morten Krogh-Jespersen | a1396cd | 2019-10-02 16:14:40 +0200 | [diff] [blame] | 956 | sys.exit(1) |
| 957 | |
Morten Krogh-Jespersen | 52d3ab0 | 2019-10-29 08:57:06 +0100 | [diff] [blame] | 958 | if args.version and not 'dev' in args.version and args.google3: |
Ian Zerny | 86c4cfd | 2022-01-17 13:43:37 +0100 | [diff] [blame] | 959 | print("WARNING: You should not roll a release version into google 3") |
Morten Krogh-Jespersen | 52d3ab0 | 2019-10-29 08:57:06 +0100 | [diff] [blame] | 960 | |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 961 | return args |
| 962 | |
| 963 | |
| 964 | def main(): |
| 965 | args = parse_options() |
| 966 | targets_to_run = [] |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 967 | |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 968 | if args.new_dev_branch: |
| 969 | if args.google3 or args.studio or args.aosp: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 970 | print('Cannot create a branch and roll at the same time.') |
Søren Gjesse | 4e5c6fe | 2019-11-05 17:17:43 +0100 | [diff] [blame] | 971 | sys.exit(1) |
| 972 | targets_to_run.append(prepare_branch(args)) |
| 973 | |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 974 | if args.dev_release: |
| 975 | if args.google3 or args.studio or args.aosp: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 976 | print('Cannot create a dev release and roll at the same time.') |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 977 | sys.exit(1) |
| 978 | targets_to_run.append(prepare_release(args)) |
| 979 | |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 980 | if (args.google3 |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 981 | or args.maven |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 982 | or (args.studio and not args.no_sync) |
Søren Gjesse | 53ef917 | 2020-06-10 15:04:01 +0200 | [diff] [blame] | 983 | or (args.desugar_library and not args.dry_run)): |
Morten Krogh-Jespersen | ec3047b | 2020-08-18 13:09:06 +0200 | [diff] [blame] | 984 | utils.check_gcert() |
Søren Gjesse | b8dec61 | 2019-10-10 09:15:43 +0200 | [diff] [blame] | 985 | |
Morten Krogh-Jespersen | 00db27f | 2019-10-02 16:14:46 +0200 | [diff] [blame] | 986 | if args.google3: |
Ian Zerny | 59dfa4c | 2019-10-25 10:34:36 +0200 | [diff] [blame] | 987 | targets_to_run.append(prepare_google3(args)) |
Morten Krogh-Jespersen | 0452794 | 2022-08-02 13:50:11 +0200 | [diff] [blame] | 988 | if args.google3retrace: |
| 989 | targets_to_run.append(prepare_google3_retrace(args)) |
Søren Gjesse | 73355ec | 2020-06-29 09:19:44 +0200 | [diff] [blame] | 990 | if args.studio and not args.update_desugar_library_in_studio: |
Morten Krogh-Jespersen | b4a7acc | 2019-10-02 10:46:32 +0200 | [diff] [blame] | 991 | targets_to_run.append(prepare_studio(args)) |
Morten Krogh-Jespersen | 00db27f | 2019-10-02 16:14:46 +0200 | [diff] [blame] | 992 | if args.aosp: |
Morten Krogh-Jespersen | b4a7acc | 2019-10-02 10:46:32 +0200 | [diff] [blame] | 993 | targets_to_run.append(prepare_aosp(args)) |
Søren Gjesse | 376b74c | 2020-06-22 08:42:44 +0200 | [diff] [blame] | 994 | if args.maven: |
| 995 | targets_to_run.append(prepare_maven(args)) |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 996 | |
Søren Gjesse | 975c5df | 2019-12-10 13:48:05 +0100 | [diff] [blame] | 997 | if args.desugar_library: |
| 998 | targets_to_run.append(prepare_desugar_library(args)) |
| 999 | |
Søren Gjesse | 73355ec | 2020-06-29 09:19:44 +0200 | [diff] [blame] | 1000 | if args.update_desugar_library_in_studio: |
| 1001 | if not args.studio: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 1002 | print("--studio required") |
Søren Gjesse | 73355ec | 2020-06-29 09:19:44 +0200 | [diff] [blame] | 1003 | sys.exit(1) |
| 1004 | if args.bug == []: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 1005 | print("Update studio mirror of com.android.tools:desugar_jdk_libs " |
Søren Gjesse | 73355ec | 2020-06-29 09:19:44 +0200 | [diff] [blame] | 1006 | + "requires at least one bug by using '--bug'") |
| 1007 | sys.exit(1) |
| 1008 | targets_to_run.append(update_desugar_library_in_studio(args)) |
| 1009 | |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 1010 | final_results = [] |
| 1011 | for target_closure in targets_to_run: |
| 1012 | final_results.append(target_closure(args)) |
| 1013 | |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 1014 | print('\n\n**************************************************************') |
| 1015 | print('PRINTING SUMMARY') |
| 1016 | print('**************************************************************\n\n') |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 1017 | |
| 1018 | for result in final_results: |
| 1019 | if result is not None: |
Morten Krogh-Jespersen | 8a4d1ca | 2021-01-19 08:27:02 +0100 | [diff] [blame] | 1020 | print(result) |
Morten Krogh-Jespersen | 1947a86 | 2019-09-26 14:06:48 +0200 | [diff] [blame] | 1021 | |
| 1022 | |
| 1023 | if __name__ == '__main__': |
| 1024 | sys.exit(main()) |