6c408a0567
* Reland: [flutter_tool] Where possible, catch only subtypes of Exception * Add armv7f to getIOSArchForName
347 lines
12 KiB
Dart
347 lines
12 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:async';
|
|
|
|
import 'package:meta/meta.dart';
|
|
|
|
import '../base/common.dart';
|
|
import '../base/io.dart';
|
|
import '../base/os.dart';
|
|
import '../base/process.dart';
|
|
import '../base/time.dart';
|
|
import '../cache.dart';
|
|
import '../dart/pub.dart';
|
|
import '../globals.dart' as globals;
|
|
import '../runner/flutter_command.dart';
|
|
import '../version.dart';
|
|
import 'channel.dart';
|
|
|
|
class UpgradeCommand extends FlutterCommand {
|
|
UpgradeCommand([UpgradeCommandRunner commandRunner])
|
|
: _commandRunner = commandRunner ?? UpgradeCommandRunner() {
|
|
argParser
|
|
..addFlag(
|
|
'force',
|
|
abbr: 'f',
|
|
help: 'Force upgrade the flutter branch, potentially discarding local changes.',
|
|
negatable: false,
|
|
)
|
|
..addFlag(
|
|
'continue',
|
|
hide: true,
|
|
negatable: false,
|
|
help: 'For the second half of the upgrade flow requiring the new '
|
|
'version of Flutter. Should not be invoked manually, but '
|
|
're-entrantly by the standard upgrade command.',
|
|
)
|
|
..addOption(
|
|
'working-directory',
|
|
hide: true,
|
|
help: 'Override the upgrade working directoy for integration testing.'
|
|
);
|
|
}
|
|
|
|
final UpgradeCommandRunner _commandRunner;
|
|
|
|
@override
|
|
final String name = 'upgrade';
|
|
|
|
@override
|
|
final String description = 'Upgrade your copy of Flutter.';
|
|
|
|
@override
|
|
bool get shouldUpdateCache => false;
|
|
|
|
@override
|
|
Future<FlutterCommandResult> runCommand() {
|
|
_commandRunner.workingDirectory = stringArg('working-directory') ?? Cache.flutterRoot;
|
|
return _commandRunner.runCommand(
|
|
force: boolArg('force'),
|
|
continueFlow: boolArg('continue'),
|
|
testFlow: stringArg('working-directory') != null,
|
|
gitTagVersion: GitTagVersion.determine(processUtils),
|
|
flutterVersion: stringArg('working-directory') == null
|
|
? globals.flutterVersion
|
|
: FlutterVersion(const SystemClock(), _commandRunner.workingDirectory),
|
|
);
|
|
}
|
|
}
|
|
|
|
@visibleForTesting
|
|
class UpgradeCommandRunner {
|
|
|
|
String workingDirectory;
|
|
|
|
Future<FlutterCommandResult> runCommand({
|
|
@required bool force,
|
|
@required bool continueFlow,
|
|
@required bool testFlow,
|
|
@required GitTagVersion gitTagVersion,
|
|
@required FlutterVersion flutterVersion,
|
|
}) async {
|
|
if (!continueFlow) {
|
|
await runCommandFirstHalf(
|
|
force: force,
|
|
gitTagVersion: gitTagVersion,
|
|
flutterVersion: flutterVersion,
|
|
testFlow: testFlow,
|
|
);
|
|
} else {
|
|
await runCommandSecondHalf(flutterVersion);
|
|
}
|
|
return FlutterCommandResult.success();
|
|
}
|
|
|
|
Future<void> runCommandFirstHalf({
|
|
@required bool force,
|
|
@required GitTagVersion gitTagVersion,
|
|
@required FlutterVersion flutterVersion,
|
|
@required bool testFlow,
|
|
}) async {
|
|
await verifyUpstreamConfigured();
|
|
if (!force && gitTagVersion == const GitTagVersion.unknown()) {
|
|
// If the commit is a recognized branch and not master,
|
|
// explain that we are avoiding potential damage.
|
|
if (flutterVersion.channel != 'master' && FlutterVersion.officialChannels.contains(flutterVersion.channel)) {
|
|
throwToolExit(
|
|
'Unknown flutter tag. Abandoning upgrade to avoid destroying local '
|
|
'changes. It is recommended to use git directly if not working on '
|
|
'an official channel.'
|
|
);
|
|
// Otherwise explain that local changes can be lost.
|
|
} else {
|
|
throwToolExit(
|
|
'Unknown flutter tag. Abandoning upgrade to avoid destroying local '
|
|
'changes. If it is okay to remove local changes, then re-run this '
|
|
'command with --force.'
|
|
);
|
|
}
|
|
}
|
|
// If there are uncommitted changes we might be on the right commit but
|
|
// we should still warn.
|
|
if (!force && await hasUncomittedChanges()) {
|
|
throwToolExit(
|
|
'Your flutter checkout has local changes that would be erased by '
|
|
'upgrading. If you want to keep these changes, it is recommended that '
|
|
'you stash them via "git stash" or else commit the changes to a local '
|
|
'branch. If it is okay to remove local changes, then re-run this '
|
|
'command with --force.'
|
|
);
|
|
}
|
|
recordState(flutterVersion);
|
|
await resetChanges(gitTagVersion);
|
|
await upgradeChannel(flutterVersion);
|
|
final bool alreadyUpToDate = await attemptFastForward(flutterVersion);
|
|
if (alreadyUpToDate) {
|
|
// If the upgrade was a no op, then do not continue with the second half.
|
|
globals.printStatus('Flutter is already up to date on channel ${flutterVersion.channel}');
|
|
globals.printStatus('$flutterVersion');
|
|
} else if (!testFlow) {
|
|
await flutterUpgradeContinue();
|
|
}
|
|
}
|
|
|
|
void recordState(FlutterVersion flutterVersion) {
|
|
final Channel channel = getChannelForName(flutterVersion.channel);
|
|
if (channel == null) {
|
|
return;
|
|
}
|
|
globals.persistentToolState.updateLastActiveVersion(flutterVersion.frameworkRevision, channel);
|
|
}
|
|
|
|
Future<void> flutterUpgradeContinue() async {
|
|
final int code = await processUtils.stream(
|
|
<String>[
|
|
globals.fs.path.join('bin', 'flutter'),
|
|
'upgrade',
|
|
'--continue',
|
|
'--no-version-check',
|
|
],
|
|
workingDirectory: workingDirectory,
|
|
allowReentrantFlutter: true,
|
|
environment: Map<String, String>.of(globals.platform.environment),
|
|
);
|
|
if (code != 0) {
|
|
throwToolExit(null, exitCode: code);
|
|
}
|
|
}
|
|
|
|
// This method should only be called if the upgrade command is invoked
|
|
// re-entrantly with the `--continue` flag
|
|
Future<void> runCommandSecondHalf(FlutterVersion flutterVersion) async {
|
|
// Make sure the welcome message re-display is delayed until the end.
|
|
globals.persistentToolState.redisplayWelcomeMessage = false;
|
|
await precacheArtifacts();
|
|
await updatePackages(flutterVersion);
|
|
await runDoctor();
|
|
// Force the welcome message to re-display following the upgrade.
|
|
globals.persistentToolState.redisplayWelcomeMessage = true;
|
|
}
|
|
|
|
Future<bool> hasUncomittedChanges() async {
|
|
try {
|
|
final RunResult result = await processUtils.run(
|
|
<String>['git', 'status', '-s'],
|
|
throwOnError: true,
|
|
workingDirectory: workingDirectory,
|
|
);
|
|
return result.stdout.trim().isNotEmpty;
|
|
} on ProcessException catch (error) {
|
|
throwToolExit(
|
|
'The tool could not verify the status of the current flutter checkout. '
|
|
'This might be due to git not being installed or an internal error. '
|
|
'If it is okay to ignore potential local changes, then re-run this '
|
|
'command with --force.'
|
|
'\nError: $error.'
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// Check if there is an upstream repository configured.
|
|
///
|
|
/// Exits tool if there is no upstream.
|
|
Future<void> verifyUpstreamConfigured() async {
|
|
try {
|
|
await processUtils.run(
|
|
<String>[ 'git', 'rev-parse', '@{u}'],
|
|
throwOnError: true,
|
|
workingDirectory: workingDirectory,
|
|
);
|
|
} on Exception {
|
|
throwToolExit(
|
|
'Unable to upgrade Flutter: no origin repository configured. '
|
|
"Run 'git remote add origin "
|
|
"https://github.com/flutter/flutter' in $workingDirectory",
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Attempts to reset to the last non-hotfix tag.
|
|
///
|
|
/// If the git history is on a hotfix, doing a fast forward will not pick up
|
|
/// major or minor version upgrades. By resetting to the point before the
|
|
/// hotfix, doing a git fast forward should succeed.
|
|
Future<void> resetChanges(GitTagVersion gitTagVersion) async {
|
|
String tag;
|
|
if (gitTagVersion == const GitTagVersion.unknown()) {
|
|
tag = 'v0.0.0';
|
|
} else {
|
|
tag = 'v${gitTagVersion.x}.${gitTagVersion.y}.${gitTagVersion.z}';
|
|
}
|
|
try {
|
|
await processUtils.run(
|
|
<String>['git', 'reset', '--hard', tag],
|
|
throwOnError: true,
|
|
workingDirectory: workingDirectory,
|
|
);
|
|
} on ProcessException catch (error) {
|
|
throwToolExit(
|
|
'Unable to upgrade Flutter: The tool could not update to the version $tag. '
|
|
'This may be due to git not being installed or an internal error. '
|
|
'Please ensure that git is installed on your computer and retry again.'
|
|
'\nError: $error.'
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Attempts to upgrade the channel.
|
|
///
|
|
/// If the user is on a deprecated channel, attempts to migrate them off of
|
|
/// it.
|
|
Future<void> upgradeChannel(FlutterVersion flutterVersion) async {
|
|
globals.printStatus('Upgrading Flutter from $workingDirectory...');
|
|
await ChannelCommand.upgradeChannel();
|
|
}
|
|
|
|
/// Attempts to rebase the upstream onto the local branch.
|
|
///
|
|
/// If there haven't been any hot fixes or local changes, this is equivalent
|
|
/// to a fast-forward.
|
|
///
|
|
/// If the fast forward lands us on the same channel and revision, then
|
|
/// returns true, otherwise returns false.
|
|
Future<bool> attemptFastForward(FlutterVersion oldFlutterVersion) async {
|
|
final int code = await processUtils.stream(
|
|
<String>['git', 'pull', '--ff'],
|
|
workingDirectory: workingDirectory,
|
|
mapFunction: (String line) => matchesGitLine(line) ? null : line,
|
|
);
|
|
if (code != 0) {
|
|
throwToolExit(null, exitCode: code);
|
|
}
|
|
|
|
// Check if the upgrade did anything.
|
|
bool alreadyUpToDate = false;
|
|
try {
|
|
final FlutterVersion newFlutterVersion = FlutterVersion(const SystemClock(), workingDirectory);
|
|
alreadyUpToDate = newFlutterVersion.channel == oldFlutterVersion.channel &&
|
|
newFlutterVersion.frameworkRevision == oldFlutterVersion.frameworkRevision;
|
|
} on Exception catch (e) {
|
|
globals.printTrace('Failed to determine FlutterVersion after upgrade fast-forward: $e');
|
|
}
|
|
return alreadyUpToDate;
|
|
}
|
|
|
|
/// Update the engine repository and precache all artifacts.
|
|
///
|
|
/// Check for and download any engine and pkg/ updates. We run the 'flutter'
|
|
/// shell script re-entrantly here so that it will download the updated
|
|
/// Dart and so forth if necessary.
|
|
Future<void> precacheArtifacts() async {
|
|
globals.printStatus('');
|
|
globals.printStatus('Upgrading engine...');
|
|
final int code = await processUtils.stream(
|
|
<String>[
|
|
globals.fs.path.join('bin', 'flutter'), '--no-color', '--no-version-check', 'precache',
|
|
],
|
|
workingDirectory: workingDirectory,
|
|
allowReentrantFlutter: true,
|
|
environment: Map<String, String>.of(globals.platform.environment),
|
|
);
|
|
if (code != 0) {
|
|
throwToolExit(null, exitCode: code);
|
|
}
|
|
}
|
|
|
|
/// Update the user's packages.
|
|
Future<void> updatePackages(FlutterVersion flutterVersion) async {
|
|
globals.printStatus('');
|
|
globals.printStatus(flutterVersion.toString());
|
|
final String projectRoot = findProjectRoot();
|
|
if (projectRoot != null) {
|
|
globals.printStatus('');
|
|
await pub.get(context: PubContext.pubUpgrade, directory: projectRoot, upgrade: true, checkLastModified: false);
|
|
}
|
|
}
|
|
|
|
/// Run flutter doctor in case requirements have changed.
|
|
Future<void> runDoctor() async {
|
|
globals.printStatus('');
|
|
globals.printStatus('Running flutter doctor...');
|
|
await processUtils.stream(
|
|
<String>[
|
|
globals.fs.path.join('bin', 'flutter'), '--no-version-check', 'doctor',
|
|
],
|
|
workingDirectory: workingDirectory,
|
|
allowReentrantFlutter: true,
|
|
);
|
|
}
|
|
|
|
// dev/benchmarks/complex_layout/lib/main.dart | 24 +-
|
|
static final RegExp _gitDiffRegex = RegExp(r' (\S+)\s+\|\s+\d+ [+-]+');
|
|
|
|
// rename {packages/flutter/doc => dev/docs}/styles.html (92%)
|
|
// delete mode 100644 doc/index.html
|
|
// create mode 100644 examples/flutter_gallery/lib/gallery/demo.dart
|
|
static final RegExp _gitChangedRegex = RegExp(r' (rename|delete mode|create mode) .+');
|
|
|
|
static bool matchesGitLine(String line) {
|
|
return _gitDiffRegex.hasMatch(line)
|
|
|| _gitChangedRegex.hasMatch(line)
|
|
|| line == 'Fast-forward';
|
|
}
|
|
}
|