282 lines
11 KiB
Dart
282 lines
11 KiB
Dart
// Copyright 2014 The Flutter Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
import 'dart:convert' show JsonEncoder, jsonDecode;
|
|
|
|
import 'package:file/file.dart' show File;
|
|
import 'package:platform/platform.dart';
|
|
|
|
import './globals.dart';
|
|
import './proto/conductor_state.pb.dart' as pb;
|
|
import './proto/conductor_state.pbenum.dart' show ReleasePhase;
|
|
|
|
const String kStateFileName = '.flutter_conductor_state.json';
|
|
|
|
String luciConsoleLink(String channel, String groupName) {
|
|
assert(
|
|
<String>['stable', 'beta', 'dev', 'master'].contains(channel),
|
|
'channel $channel not recognized',
|
|
);
|
|
assert(
|
|
<String>['framework', 'engine', 'devicelab', 'packaging'].contains(groupName),
|
|
'group named $groupName not recognized',
|
|
);
|
|
final String consoleName = channel == 'master' ? groupName : '${channel}_$groupName';
|
|
return 'https://ci.chromium.org/p/flutter/g/$consoleName/console';
|
|
}
|
|
|
|
String defaultStateFilePath(Platform platform) {
|
|
final String? home = platform.environment['HOME'];
|
|
if (home == null) {
|
|
throw ConductorException(r'Environment variable $HOME must be set!');
|
|
}
|
|
return <String>[
|
|
home,
|
|
kStateFileName,
|
|
].join(platform.pathSeparator);
|
|
}
|
|
|
|
String presentState(pb.ConductorState state) {
|
|
final StringBuffer buffer = StringBuffer();
|
|
buffer.writeln('Conductor version: ${state.conductorVersion}');
|
|
buffer.writeln('Release channel: ${state.releaseChannel}');
|
|
buffer.writeln('Release version: ${state.releaseVersion}');
|
|
buffer.writeln('');
|
|
buffer.writeln('Release started at: ${DateTime.fromMillisecondsSinceEpoch(state.createdDate.toInt())}');
|
|
buffer.writeln('Last updated at: ${DateTime.fromMillisecondsSinceEpoch(state.lastUpdatedDate.toInt())}');
|
|
buffer.writeln('');
|
|
buffer.writeln('Engine Repo');
|
|
buffer.writeln('\tCandidate branch: ${state.engine.candidateBranch}');
|
|
buffer.writeln('\tStarting git HEAD: ${state.engine.startingGitHead}');
|
|
buffer.writeln('\tCurrent git HEAD: ${state.engine.currentGitHead}');
|
|
buffer.writeln('\tPath to checkout: ${state.engine.checkoutPath}');
|
|
buffer.writeln('\tPost-submit LUCI dashboard: ${luciConsoleLink(state.releaseChannel, 'engine')}');
|
|
if (state.engine.cherrypicks.isNotEmpty) {
|
|
buffer.writeln('${state.engine.cherrypicks.length} Engine Cherrypicks:');
|
|
for (final pb.Cherrypick cherrypick in state.engine.cherrypicks) {
|
|
buffer.writeln('\t${cherrypick.trunkRevision} - ${cherrypick.state}');
|
|
}
|
|
} else {
|
|
buffer.writeln('0 Engine cherrypicks.');
|
|
}
|
|
if (state.engine.dartRevision != null && state.engine.dartRevision.isNotEmpty) {
|
|
buffer.writeln('New Dart SDK revision: ${state.engine.dartRevision}');
|
|
}
|
|
buffer.writeln('Framework Repo');
|
|
buffer.writeln('\tCandidate branch: ${state.framework.candidateBranch}');
|
|
buffer.writeln('\tStarting git HEAD: ${state.framework.startingGitHead}');
|
|
buffer.writeln('\tCurrent git HEAD: ${state.framework.currentGitHead}');
|
|
buffer.writeln('\tPath to checkout: ${state.framework.checkoutPath}');
|
|
buffer.writeln('\tPost-submit LUCI dashboard: ${luciConsoleLink(state.releaseChannel, 'framework')}');
|
|
buffer.writeln('\tDevicelab LUCI dashboard: ${luciConsoleLink(state.releaseChannel, 'devicelab')}');
|
|
if (state.framework.cherrypicks.isNotEmpty) {
|
|
buffer.writeln('${state.framework.cherrypicks.length} Framework Cherrypicks:');
|
|
for (final pb.Cherrypick cherrypick in state.framework.cherrypicks) {
|
|
buffer.writeln('\t${cherrypick.trunkRevision} - ${cherrypick.state}');
|
|
}
|
|
} else {
|
|
buffer.writeln('0 Framework cherrypicks.');
|
|
}
|
|
buffer.writeln('');
|
|
if (state.currentPhase == ReleasePhase.VERIFY_RELEASE) {
|
|
buffer.writeln(
|
|
'${state.releaseChannel} release ${state.releaseVersion} has been published and verified.\n',
|
|
);
|
|
return buffer.toString();
|
|
}
|
|
buffer.writeln('The current phase is:');
|
|
buffer.writeln(presentPhases(state.currentPhase));
|
|
|
|
buffer.writeln(phaseInstructions(state));
|
|
buffer.writeln('');
|
|
buffer.writeln('Issue `conductor next` when you are ready to proceed.');
|
|
return buffer.toString();
|
|
}
|
|
|
|
String presentPhases(ReleasePhase currentPhase) {
|
|
final StringBuffer buffer = StringBuffer();
|
|
bool phaseCompleted = true;
|
|
|
|
for (final ReleasePhase phase in ReleasePhase.values) {
|
|
if (phase == currentPhase) {
|
|
// This phase will execute the next time `conductor next` is run.
|
|
buffer.writeln('> ${phase.name} (current)');
|
|
phaseCompleted = false;
|
|
} else if (phaseCompleted) {
|
|
// This phase was already completed.
|
|
buffer.writeln('✓ ${phase.name}');
|
|
} else {
|
|
// This phase has not been completed yet.
|
|
buffer.writeln(' ${phase.name}');
|
|
}
|
|
}
|
|
return buffer.toString();
|
|
}
|
|
|
|
String phaseInstructions(pb.ConductorState state) {
|
|
switch (state.currentPhase) {
|
|
case ReleasePhase.APPLY_ENGINE_CHERRYPICKS:
|
|
if (state.engine.cherrypicks.isEmpty) {
|
|
return <String>[
|
|
'There are no engine cherrypicks, so issue `conductor next` to continue',
|
|
'to the next step.',
|
|
].join('\n');
|
|
}
|
|
return <String>[
|
|
'You must now manually apply the following engine cherrypicks to the checkout',
|
|
'at ${state.engine.checkoutPath} in order:',
|
|
for (final pb.Cherrypick cherrypick in state.engine.cherrypicks) '\t${cherrypick.trunkRevision}',
|
|
'See $kReleaseDocumentationUrl for more information.',
|
|
].join('\n');
|
|
case ReleasePhase.CODESIGN_ENGINE_BINARIES:
|
|
if (!requiresEnginePR(state)) {
|
|
return 'You must now codesign the engine binaries for commit '
|
|
'${state.engine.startingGitHead}.';
|
|
}
|
|
// User's working branch was pushed to their mirror, but a PR needs to be
|
|
// opened on GitHub.
|
|
final String newPrLink = getNewPrLink(
|
|
userName: githubAccount(state.engine.mirror.url),
|
|
repoName: 'engine',
|
|
state: state,
|
|
);
|
|
return <String>[
|
|
'Your working branch ${state.engine.workingBranch} was pushed to your mirror.',
|
|
'You must now open a pull request at $newPrLink, verify pre-submit CI',
|
|
'builds on your engine pull request are successful, merge your pull request,',
|
|
'validate post-submit CI, and then codesign the binaries on the merge commit.',
|
|
].join('\n');
|
|
case ReleasePhase.APPLY_FRAMEWORK_CHERRYPICKS:
|
|
final List<pb.Cherrypick> outstandingCherrypicks = state.framework.cherrypicks.where(
|
|
(pb.Cherrypick cp) {
|
|
return cp.state == pb.CherrypickState.PENDING || cp.state == pb.CherrypickState.PENDING_WITH_CONFLICT;
|
|
},
|
|
).toList();
|
|
if (outstandingCherrypicks.isNotEmpty) {
|
|
return <String>[
|
|
'You must now manually apply the following framework cherrypicks to the checkout',
|
|
'at ${state.framework.checkoutPath} in order:',
|
|
for (final pb.Cherrypick cherrypick in outstandingCherrypicks) '\t${cherrypick.trunkRevision}',
|
|
].join('\n');
|
|
}
|
|
return <String>['Either all cherrypicks have been auto-applied or there were none.'].join('\n');
|
|
case ReleasePhase.PUBLISH_VERSION:
|
|
if (!requiresFrameworkPR(state)) {
|
|
return 'Since there are no code changes in this release, no Framework '
|
|
'PR is necessary.';
|
|
}
|
|
|
|
final String newPrLink = getNewPrLink(
|
|
userName: githubAccount(state.framework.mirror.url),
|
|
repoName: 'flutter',
|
|
state: state,
|
|
);
|
|
return <String>[
|
|
'Your working branch ${state.framework.workingBranch} was pushed to your mirror.',
|
|
'You must now open a pull request at $newPrLink',
|
|
'verify pre-submit CI builds on your pull request are successful, merge your ',
|
|
'pull request, validate post-submit CI.',
|
|
].join('\n');
|
|
case ReleasePhase.PUBLISH_CHANNEL:
|
|
return 'Issue `conductor next` to publish your release to the release branch.';
|
|
case ReleasePhase.VERIFY_RELEASE:
|
|
return 'Release archive packages must be verified on cloud storage: ${luciConsoleLink(state.releaseChannel, 'packaging')}';
|
|
case ReleasePhase.RELEASE_COMPLETED:
|
|
return 'This release has been completed.';
|
|
}
|
|
// For analyzer
|
|
throw ConductorException('Unimplemented phase ${state.currentPhase}');
|
|
}
|
|
|
|
/// Regex pattern for git remote host URLs.
|
|
///
|
|
/// First group = git host (currently must be github.com)
|
|
/// Second group = account name
|
|
/// Third group = repo name
|
|
final RegExp githubRemotePattern =
|
|
RegExp(r'^(git@github\.com:|https?:\/\/github\.com\/)([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_-]+)(\.git)?$');
|
|
|
|
/// Parses a Git remote URL and returns the account name.
|
|
///
|
|
/// Uses [githubRemotePattern].
|
|
String githubAccount(String remoteUrl) {
|
|
final String engineUrl = remoteUrl;
|
|
final RegExpMatch? match = githubRemotePattern.firstMatch(engineUrl);
|
|
if (match == null) {
|
|
throw ConductorException(
|
|
'Cannot determine the GitHub account from $engineUrl',
|
|
);
|
|
}
|
|
final String? accountName = match.group(2);
|
|
if (accountName == null || accountName.isEmpty) {
|
|
throw ConductorException(
|
|
'Cannot determine the GitHub account from $match',
|
|
);
|
|
}
|
|
return accountName;
|
|
}
|
|
|
|
/// Returns the next phase in the ReleasePhase enum.
|
|
///
|
|
/// Will throw a [ConductorException] if [ReleasePhase.RELEASE_COMPLETED] is
|
|
/// passed as an argument, as there is no next phase.
|
|
ReleasePhase getNextPhase(ReleasePhase currentPhase) {
|
|
assert(currentPhase != null);
|
|
final ReleasePhase? nextPhase = ReleasePhase.valueOf(currentPhase.value + 1);
|
|
if (nextPhase == null) {
|
|
throw ConductorException('There is no next ReleasePhase!');
|
|
}
|
|
return nextPhase;
|
|
}
|
|
|
|
// Indent two spaces.
|
|
const JsonEncoder _encoder = JsonEncoder.withIndent(' ');
|
|
|
|
void writeStateToFile(File file, pb.ConductorState state, List<String> logs) {
|
|
state.logs.addAll(logs);
|
|
file.writeAsStringSync(
|
|
_encoder.convert(state.toProto3Json()),
|
|
flush: true,
|
|
);
|
|
}
|
|
|
|
pb.ConductorState readStateFromFile(File file) {
|
|
final pb.ConductorState state = pb.ConductorState();
|
|
final String stateAsString = file.readAsStringSync();
|
|
state.mergeFromProto3Json(
|
|
jsonDecode(stateAsString),
|
|
);
|
|
return state;
|
|
}
|
|
|
|
/// This release will require a new Engine PR.
|
|
///
|
|
/// The logic is if there are engine cherrypicks that have not been abandoned OR
|
|
/// there is a new Dart revision, then return true, else false.
|
|
bool requiresEnginePR(pb.ConductorState state) {
|
|
final bool hasRequiredCherrypicks = state.engine.cherrypicks.any(
|
|
(pb.Cherrypick cp) => cp.state != pb.CherrypickState.ABANDONED,
|
|
);
|
|
if (hasRequiredCherrypicks) {
|
|
return true;
|
|
}
|
|
return state.engine.dartRevision.isNotEmpty;
|
|
}
|
|
|
|
/// This release will require a new Framework PR.
|
|
///
|
|
/// The logic is if there was an Engine PR OR there are framework cherrypicks
|
|
/// that have not been abandoned.
|
|
bool requiresFrameworkPR(pb.ConductorState state) {
|
|
if (requiresEnginePR(state)) {
|
|
return true;
|
|
}
|
|
final bool hasRequiredCherrypicks =
|
|
state.framework.cherrypicks.any((pb.Cherrypick cp) => cp.state != pb.CherrypickState.ABANDONED);
|
|
if (hasRequiredCherrypicks) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|