lts/deps/v8/tools/release/auto_roll.py
#!/usr/bin/env python
# Copyright 2014 the V8 project authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
# for py2/py3 compatibility
from __future__ import print_function
import argparse
import os
import sys
from common_includes import *
ROLL_SUMMARY = ("Summary of changes available at:\n"
"https://chromium.googlesource.com/v8/v8/+log/%s..%s")
ISSUE_MSG = (
"""Please follow these instructions for assigning/CC'ing issues:
https://v8.dev/docs/triage-issues
Please close rolling in case of a roll revert:
https://v8-roll.appspot.com/
This only works with a Google account.
CQ_INCLUDE_TRYBOTS=luci.chromium.try:linux-blink-rel
CQ_INCLUDE_TRYBOTS=luci.chromium.try:linux_optional_gpu_tests_rel
CQ_INCLUDE_TRYBOTS=luci.chromium.try:mac_optional_gpu_tests_rel
CQ_INCLUDE_TRYBOTS=luci.chromium.try:win_optional_gpu_tests_rel
CQ_INCLUDE_TRYBOTS=luci.chromium.try:android_optional_gpu_tests_rel""")
class Preparation(Step):
MESSAGE = "Preparation."
def RunStep(self):
self['json_output']['monitoring_state'] = 'preparation'
# Update v8 remote tracking branches.
self.GitFetchOrigin()
self.Git("fetch origin +refs/tags/*:refs/tags/*")
class DetectLastRoll(Step):
MESSAGE = "Detect commit ID of the last Chromium roll."
def RunStep(self):
self['json_output']['monitoring_state'] = 'detect_last_roll'
self["last_roll"] = self._options.last_roll
if not self["last_roll"]:
# Interpret the DEPS file to retrieve the v8 revision.
# TODO(machenbach): This should be part or the setdep api of
# depot_tools.
Var = lambda var: '%s'
exec(FileToText(os.path.join(self._options.chromium, "DEPS")))
# The revision rolled last.
self["last_roll"] = vars['v8_revision']
self["last_version"] = self.GetVersionTag(self["last_roll"])
assert self["last_version"], "The last rolled v8 revision is not tagged."
class DetectRevisionToRoll(Step):
MESSAGE = "Detect commit ID of the V8 revision to roll."
def RunStep(self):
self['json_output']['monitoring_state'] = 'detect_revision'
self["roll"] = self._options.revision
if self["roll"]:
# If the revision was passed on the cmd line, continue script execution
# in the next step.
return False
# The revision that should be rolled. Check for the latest of the most
# recent releases based on commit timestamp.
revisions = self.GetRecentReleases(
max_age=self._options.max_age * DAY_IN_SECONDS)
assert revisions, "Didn't find any recent release."
# There must be some progress between the last roll and the new candidate
# revision (i.e. we don't go backwards). The revisions are ordered newest
# to oldest. It is possible that the newest timestamp has no progress
# compared to the last roll, i.e. if the newest release is a cherry-pick
# on a release branch. Then we look further.
for revision in revisions:
version = self.GetVersionTag(revision)
assert version, "Internal error. All recent releases should have a tag"
if SortingKey(self["last_version"]) < SortingKey(version):
self["roll"] = revision
break
else:
print("There is no newer v8 revision than the one in Chromium (%s)."
% self["last_roll"])
self['json_output']['monitoring_state'] = 'up_to_date'
return True
class PrepareRollCandidate(Step):
MESSAGE = "Robustness checks of the roll candidate."
def RunStep(self):
self['json_output']['monitoring_state'] = 'prepare_candidate'
self["roll_title"] = self.GitLog(n=1, format="%s",
git_hash=self["roll"])
# Make sure the last roll and the roll candidate are releases.
version = self.GetVersionTag(self["roll"])
assert version, "The revision to roll is not tagged."
version = self.GetVersionTag(self["last_roll"])
assert version, "The revision used as last roll is not tagged."
class SwitchChromium(Step):
MESSAGE = "Switch to Chromium checkout."
def RunStep(self):
self['json_output']['monitoring_state'] = 'switch_chromium'
cwd = self._options.chromium
self.InitialEnvironmentChecks(cwd)
# Check for a clean workdir.
if not self.GitIsWorkdirClean(cwd=cwd): # pragma: no cover
self.Die("Workspace is not clean. Please commit or undo your changes.")
# Assert that the DEPS file is there.
if not os.path.exists(os.path.join(cwd, "DEPS")): # pragma: no cover
self.Die("DEPS file not present.")
class UpdateChromiumCheckout(Step):
MESSAGE = "Update the checkout and create a new branch."
def RunStep(self):
self['json_output']['monitoring_state'] = 'update_chromium'
cwd = self._options.chromium
self.GitCheckout("master", cwd=cwd)
self.DeleteBranch("work-branch", cwd=cwd)
self.GitPull(cwd=cwd)
# Update v8 remotes.
self.GitFetchOrigin()
self.GitCreateBranch("work-branch", cwd=cwd)
class UploadCL(Step):
MESSAGE = "Create and upload CL."
def RunStep(self):
self['json_output']['monitoring_state'] = 'upload'
cwd = self._options.chromium
# Patch DEPS file.
if self.Command("gclient", "setdep -r src/v8@%s" %
self["roll"], cwd=cwd) is None:
self.Die("Failed to create deps for %s" % self["roll"])
message = []
message.append("Update V8 to %s." % self["roll_title"].lower())
message.append(
ROLL_SUMMARY % (self["last_roll"][:8], self["roll"][:8]))
message.append(ISSUE_MSG)
message.append("TBR=%s" % self._options.reviewer)
self.GitCommit("\n\n".join(message), author=self._options.author, cwd=cwd)
if not self._options.dry_run:
self.GitUpload(force=True,
bypass_hooks=True,
cq=self._options.use_commit_queue,
cq_dry_run=self._options.use_dry_run,
cwd=cwd)
print("CL uploaded.")
else:
print("Dry run - don't upload.")
self.GitCheckout("master", cwd=cwd)
self.GitDeleteBranch("work-branch", cwd=cwd)
class CleanUp(Step):
MESSAGE = "Done!"
def RunStep(self):
self['json_output']['monitoring_state'] = 'success'
print("Congratulations, you have successfully rolled %s into "
"Chromium."
% self["roll"])
# Clean up all temporary files.
Command("rm", "-f %s*" % self._config["PERSISTFILE_BASENAME"])
class AutoRoll(ScriptsBase):
def _PrepareOptions(self, parser):
parser.add_argument("-c", "--chromium", required=True,
help=("The path to your Chromium src/ "
"directory to automate the V8 roll."))
parser.add_argument("--last-roll",
help="The git commit ID of the last rolled version. "
"Auto-detected if not specified.")
parser.add_argument("--max-age", default=7, type=int,
help="Maximum age in days of the latest release.")
parser.add_argument("--revision",
help="Revision to roll. Auto-detected if not "
"specified."),
parser.add_argument("--roll", help="Deprecated.",
default=True, action="store_true")
group = parser.add_mutually_exclusive_group()
group.add_argument("--use-commit-queue",
help="Trigger the CQ full run on upload.",
default=False, action="store_true")
group.add_argument("--use-dry-run",
help="Trigger the CQ dry run on upload.",
default=True, action="store_true")
def _ProcessOptions(self, options): # pragma: no cover
if not options.author or not options.reviewer:
print("A reviewer (-r) and an author (-a) are required.")
return False
options.requires_editor = False
options.force = True
options.manual = False
return True
def _Config(self):
return {
"PERSISTFILE_BASENAME": "/tmp/v8-chromium-roll-tempfile",
}
def _Steps(self):
return [
Preparation,
DetectLastRoll,
DetectRevisionToRoll,
PrepareRollCandidate,
SwitchChromium,
UpdateChromiumCheckout,
UploadCL,
CleanUp,
]
if __name__ == "__main__": # pragma: no cover
sys.exit(AutoRoll().Run())