packages/flutter_tools/lib/src/version.dart - mirrors/flutter - Git at Google

 // Copyright 2015 The Chromium 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 'dart:convert';

 import 'package:meta/meta.dart';
 import 'package:quiver/time.dart';

 import 'base/common.dart';
 import 'base/context.dart';
 import 'base/io.dart';
 import 'base/process.dart';
 import 'base/process_manager.dart';
 import 'cache.dart';
 import 'globals.dart';

 final Set<String> kKnownBranchNames = new Set<String>.from(<String>[
   'master',
   'alpha',
   'hackathon',
   'codelab',
   'beta'
 ]);

 class FlutterVersion {
   @visibleForTesting
   FlutterVersion(this._clock) {
     _channel = _runGit('git rev-parse --abbrev-ref --symbolic @{u}');

     final int slash = _channel.indexOf('/');
     if (slash != -1) {
       final String remote = _channel.substring(0, slash);
       _repositoryUrl = _runGit('git ls-remote --get-url $remote');
       _channel = _channel.substring(slash + 1);
     } else if (_channel.isEmpty) {
       _channel = 'unknown';
     }

     _frameworkRevision = _runGit('git log -n 1 --pretty=format:%H');
     _frameworkAge = _runGit('git log -n 1 --pretty=format:%ar');
   }

   final Clock _clock;

   String _repositoryUrl;
   String get repositoryUrl => _repositoryUrl;

   String _channel;
   /// `master`, `alpha`, `hackathon`, ...
   String get channel => _channel;

   String _frameworkRevision;
   String get frameworkRevision => _frameworkRevision;
   String get frameworkRevisionShort => _shortGitRevision(frameworkRevision);

   String _frameworkAge;
   String get frameworkAge => _frameworkAge;

   String get frameworkDate => frameworkCommitDate;

   String get dartSdkVersion => Cache.dartSdkVersion.split(' ')[0];

   String get engineRevision => Cache.engineRevision;
   String get engineRevisionShort => _shortGitRevision(engineRevision);

   String _runGit(String command) => runSync(command.split(' '), workingDirectory: Cache.flutterRoot);

   @override
   String toString() {
     final String flutterText = 'Flutter • channel $channel • ${repositoryUrl == null ? 'unknown source' : repositoryUrl}';
     final String frameworkText = 'Framework • revision $frameworkRevisionShort ($frameworkAge) • $frameworkCommitDate';
     final String engineText = 'Engine • revision $engineRevisionShort';
     final String toolsText = 'Tools • Dart $dartSdkVersion';

     // Flutter • channel master • https://github.com/flutter/flutter.git
     // Framework • revision 2259c59be8 • 19 minutes ago • 2016-08-15 22:51:40
     // Engine • revision fe509b0d96
     // Tools • Dart 1.19.0-dev.5.0

     return '$flutterText\n$frameworkText\n$engineText\n$toolsText';
   }

   Map<String, Object> toJson() => <String, Object>{
         'channel': channel,
         'repositoryUrl': repositoryUrl ?? 'unknown source',
         'frameworkRevision': frameworkRevision,
         'frameworkCommitDate': frameworkCommitDate,
         'engineRevision': engineRevision,
         'dartSdkVersion': dartSdkVersion,
       };

   /// A date String describing the last framework commit.
   String get frameworkCommitDate => _latestGitCommitDate();

   static String _latestGitCommitDate([String branch]) {
     final List<String> args = <String>['git', 'log'];

     if (branch != null)
       args.add(branch);

     args.addAll(<String>['-n', '1', '--pretty=format:%ad', '--date=iso']);
     return _runSync(args, lenient: false);
   }

   /// The name of the temporary git remote used to check for the latest
   /// available Flutter framework version.
   ///
   /// In the absence of bugs and crashes a Flutter developer should never see
   /// this remote appear in their `git remote` list, but also if it happens to
   /// persist we do the proper clean-up for extra robustness.
   static const String _kVersionCheckRemote = '__flutter_version_check__';

   /// The date of the latest framework commit in the remote repository.
   ///
   /// Throws [ToolExit] if a git command fails, for example, when the remote git
   /// repository is not reachable due to a network issue.
   static Future<String> fetchRemoteFrameworkCommitDate(String branch) async {
     await _removeVersionCheckRemoteIfExists();
     try {
       await _run(<String>[
         'git',
         'remote',
         'add',
         _kVersionCheckRemote,
         'https://github.com/flutter/flutter.git',
       ]);
       await _run(<String>['git', 'fetch', _kVersionCheckRemote, branch]);
       return _latestGitCommitDate('$_kVersionCheckRemote/$branch');
     } finally {
       await _removeVersionCheckRemoteIfExists();
     }
   }

   static Future<Null> _removeVersionCheckRemoteIfExists() async {
     final List<String> remotes = (await _run(<String>['git', 'remote']))
         .split('\n')
         .map((String name) => name.trim())  // to account for OS-specific line-breaks
         .toList();
     if (remotes.contains(_kVersionCheckRemote))
       await _run(<String>['git', 'remote', 'remove', _kVersionCheckRemote]);
   }

   static FlutterVersion get instance => context.putIfAbsent(FlutterVersion, () => new FlutterVersion(const Clock()));

   /// Return a short string for the version (`alpha/a76bc8e22b`).
   static String getVersionString({ bool whitelistBranchName: false }) {
     String commit = _shortGitRevision(_runSync(<String>['git', 'rev-parse', 'HEAD']));
     commit = commit.isEmpty ? 'unknown' : commit;

     String branch = _runSync(<String>['git', 'rev-parse', '--abbrev-ref', 'HEAD']);
     branch = branch == 'HEAD' ? 'master' : branch;

     if (whitelistBranchName || branch.isEmpty) {
       // Only return the branch names we know about; arbitrary branch names might contain PII.
       if (!kKnownBranchNames.contains(branch))
         branch = 'dev';
     }

     return '$branch/$commit';
   }

   /// The amount of time we wait before pinging the server to check for the
   /// availability of a newer version of Flutter.
   @visibleForTesting
   static const Duration kCheckAgeConsideredUpToDate = const Duration(days: 7);

   /// We warn the user if the age of their Flutter installation is greater than
   /// this duration.
   @visibleForTesting
   static final Duration kVersionAgeConsideredUpToDate = kCheckAgeConsideredUpToDate * 4;

   /// The amount of time we wait between issuing a warning.
   ///
   /// This is to avoid annoying users who are unable to upgrade right away.
   @visibleForTesting
   static const Duration kMaxTimeSinceLastWarning = const Duration(days: 1);

   /// The amount of time we pause for to let the user read the message about
   /// outdated Flutter installation.
   ///
   /// This can be customized in tests to speed them up.
   @visibleForTesting
   static Duration kPauseToLetUserReadTheMessage = const Duration(seconds: 2);

   /// Checks if the currently installed version of Flutter is up-to-date, and
   /// warns the user if it isn't.
   ///
   /// This function must run while [Cache.lock] is acquired because it reads and
   /// writes shared cache files.
   Future<Null> checkFlutterVersionFreshness() async {
     final DateTime localFrameworkCommitDate = DateTime.parse(frameworkCommitDate);
     final Duration frameworkAge = _clock.now().difference(localFrameworkCommitDate);
     final bool installationSeemsOutdated = frameworkAge > kVersionAgeConsideredUpToDate;

     Future<bool> newerFrameworkVersionAvailable() async {
       final DateTime latestFlutterCommitDate = await _getLatestAvailableFlutterVersion();

       if (latestFlutterCommitDate == null)
         return false;

       return latestFlutterCommitDate.isAfter(localFrameworkCommitDate);
     }

     final VersionCheckStamp stamp = await VersionCheckStamp.load();
     final DateTime lastTimeWarningWasPrinted = stamp.lastTimeWarningWasPrinted ?? _clock.agoBy(kMaxTimeSinceLastWarning * 2);
     final bool beenAWhileSinceWarningWasPrinted = _clock.now().difference(lastTimeWarningWasPrinted) > kMaxTimeSinceLastWarning;

     if (beenAWhileSinceWarningWasPrinted && installationSeemsOutdated && await newerFrameworkVersionAvailable()) {
       printStatus(versionOutOfDateMessage(frameworkAge), emphasis: true);
       final Future<Null> saveWarningStampFuture = stamp.store(
         newTimeWarningWasPrinted: _clock.now(),
       );
       await Future.wait<Null>(<Future<Null>>[
         saveWarningStampFuture,
         new Future<Null>.delayed(kPauseToLetUserReadTheMessage),
       ]);
     }
   }

   @visibleForTesting
   static String versionOutOfDateMessage(Duration frameworkAge) {
     String warning = 'WARNING: your installation of Flutter is ${frameworkAge.inDays} days old.';
     // Append enough spaces to match the message box width.
     warning += ' ' * (74 - warning.length);

     return '''
   ╔════════════════════════════════════════════════════════════════════════════╗
   ║ $warning ║
   ║                                                                            ║
   ║ To update to the latest version, run "flutter upgrade".                    ║
   ╚════════════════════════════════════════════════════════════════════════════╝
 ''';
   }

   /// Gets the release date of the latest available Flutter version.
   ///
   /// This method sends a server request if it's been more than
   /// [kCheckAgeConsideredUpToDate] since the last version check.
   ///
   /// Returns null if the cached version is out-of-date or missing, and we are
   /// unable to reach the server to get the latest version.
   Future<DateTime> _getLatestAvailableFlutterVersion() async {
     Cache.checkLockAcquired();
     final VersionCheckStamp versionCheckStamp = await VersionCheckStamp.load();

     if (versionCheckStamp.lastTimeVersionWasChecked != null) {
       final Duration timeSinceLastCheck = _clock.now().difference(versionCheckStamp.lastTimeVersionWasChecked);

       // Don't ping the server too often. Return cached value if it's fresh.
       if (timeSinceLastCheck < kCheckAgeConsideredUpToDate)
         return versionCheckStamp.lastKnownRemoteVersion;
     }

     // Cache is empty or it's been a while since the last server ping. Ping the server.
     try {
       final String branch = _channel == 'alpha' ? 'alpha' : 'master';
       final DateTime remoteFrameworkCommitDate = DateTime.parse(await FlutterVersion.fetchRemoteFrameworkCommitDate(branch));
       // fire and forget since nothing subsequent depends on it. Hope there's a flush/sync mechanism.
       // ignore: unawaited_futures
       versionCheckStamp.store(
         newTimeVersionWasChecked: _clock.now(),
         newKnownRemoteVersion: remoteFrameworkCommitDate,
       );
       return remoteFrameworkCommitDate;
     } on VersionCheckError catch (error) {
       // This happens when any of the git commands fails, which can happen when
       // there's no Internet connectivity. Remote version check is best effort
       // only. We do not prevent the command from running when it fails.
       printTrace('Failed to check Flutter version in the remote repository: $error');
       return null;
     }
   }
 }

 /// Contains data and load/save logic pertaining to Flutter version checks.
 @visibleForTesting
 class VersionCheckStamp {
   /// The prefix of the stamp file where we cache Flutter version check data.
   @visibleForTesting
   static const String kFlutterVersionCheckStampFile = 'flutter_version_check';

   const VersionCheckStamp({
     this.lastTimeVersionWasChecked,
     this.lastKnownRemoteVersion,
     this.lastTimeWarningWasPrinted,
   });

   final DateTime lastTimeVersionWasChecked;
   final DateTime lastKnownRemoteVersion;
   final DateTime lastTimeWarningWasPrinted;

   static Future<VersionCheckStamp> load() async {
     final String versionCheckStamp = Cache.instance.getStampFor(kFlutterVersionCheckStampFile);

     if (versionCheckStamp != null) {
       // Attempt to parse stamp JSON.
       try {
         final dynamic json = JSON.decode(versionCheckStamp);
         if (json is Map) {
           return fromJson(json);
         } else {
           printTrace('Warning: expected version stamp to be a Map but found: $json');
         }
       } catch (error, stackTrace) {
         // Do not crash if JSON is malformed.
         printTrace('${error.runtimeType}: $error\n$stackTrace');
       }
     }

     // Stamp is missing or is malformed.
     return const VersionCheckStamp();
   }

   static VersionCheckStamp fromJson(Map<String, String> json) {
     DateTime readDateTime(String property) {
       return json.containsKey(property)
         ? DateTime.parse(json[property])
         : null;
     }

     return new VersionCheckStamp(
       lastTimeVersionWasChecked: readDateTime('lastTimeVersionWasChecked'),
       lastKnownRemoteVersion: readDateTime('lastKnownRemoteVersion'),
       lastTimeWarningWasPrinted: readDateTime('lastTimeWarningWasPrinted'),
     );
   }

   Future<Null> store({
     DateTime newTimeVersionWasChecked,
     DateTime newKnownRemoteVersion,
     DateTime newTimeWarningWasPrinted,
   }) async {
     final Map<String, String> jsonData = toJson();

     if (newTimeVersionWasChecked != null)
       jsonData['lastTimeVersionWasChecked'] = '$newTimeVersionWasChecked';

     if (newKnownRemoteVersion != null)
       jsonData['lastKnownRemoteVersion'] = '$newKnownRemoteVersion';

     if (newTimeWarningWasPrinted != null)
       jsonData['lastTimeWarningWasPrinted'] = '$newTimeWarningWasPrinted';

     const JsonEncoder kPrettyJsonEncoder = const JsonEncoder.withIndent('  ');
     Cache.instance.setStampFor(kFlutterVersionCheckStampFile, kPrettyJsonEncoder.convert(jsonData));
   }

   Map<String, String> toJson({
     DateTime updateTimeVersionWasChecked,
     DateTime updateKnownRemoteVersion,
     DateTime updateTimeWarningWasPrinted,
   }) {
     updateTimeVersionWasChecked = updateTimeVersionWasChecked ?? lastTimeVersionWasChecked;
     updateKnownRemoteVersion = updateKnownRemoteVersion ?? lastKnownRemoteVersion;
     updateTimeWarningWasPrinted = updateTimeWarningWasPrinted ?? lastTimeWarningWasPrinted;

     final Map<String, String> jsonData = <String, String>{};

     if (updateTimeVersionWasChecked != null)
       jsonData['lastTimeVersionWasChecked'] = '$updateTimeVersionWasChecked';

     if (updateKnownRemoteVersion != null)
       jsonData['lastKnownRemoteVersion'] = '$updateKnownRemoteVersion';

     if (updateTimeWarningWasPrinted != null)
       jsonData['lastTimeWarningWasPrinted'] = '$updateTimeWarningWasPrinted';

     return jsonData;
   }
 }

 /// Thrown when we fail to check Flutter version.
 ///
 /// This can happen when we attempt to `git fetch` but there is no network, or
 /// when the installation is not git-based (e.g. a user clones the repo but
 /// then removes .git).
 class VersionCheckError implements Exception {

   VersionCheckError(this.message);

   final String message;

   @override
   String toString() => '$VersionCheckError: $message';
 }

 /// Runs [command] and returns the standard output as a string.
 ///
 /// If [lenient] is `true` and the command fails, returns an empty string.
 /// Otherwise, throws a [ToolExit] exception.
 String _runSync(List<String> command, {bool lenient: true}) {
   final ProcessResult results = processManager.runSync(command, workingDirectory: Cache.flutterRoot);

   if (results.exitCode == 0)
     return results.stdout.trim();

   if (!lenient) {
     throw new VersionCheckError(
       'Command exited with code ${results.exitCode}: ${command.join(' ')}\n'
       'Standard error: ${results.stderr}'
     );
   }

   return '';
 }

 /// Runs [command] in the root of the Flutter installation and returns the
 /// standard output as a string.
 ///
 /// If the command fails, throws a [ToolExit] exception.
 Future<String> _run(List<String> command) async {
   final ProcessResult results = await processManager.run(command, workingDirectory: Cache.flutterRoot);

   if (results.exitCode == 0)
     return results.stdout.trim();

   throw new VersionCheckError(
     'Command exited with code ${results.exitCode}: ${command.join(' ')}\n'
     'Standard error: ${results.stderr}'
   );
 }

 String _shortGitRevision(String revision) {
   if (revision == null)
     return '';
   return revision.length > 10 ? revision.substring(0, 10) : revision;
 }
	// Copyright 2015 The Chromium 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 'dart:convert';

	import 'package:meta/meta.dart';
	import 'package:quiver/time.dart';

	import 'base/common.dart';
	import 'base/context.dart';
	import 'base/io.dart';
	import 'base/process.dart';
	import 'base/process_manager.dart';
	import 'cache.dart';
	import 'globals.dart';

	final Set<String> kKnownBranchNames = new Set<String>.from(<String>[
	'master',
	'alpha',
	'hackathon',
	'codelab',
	'beta'
	]);

	class FlutterVersion {
	@visibleForTesting
	FlutterVersion(this._clock) {
	_channel = _runGit('git rev-parse --abbrev-ref --symbolic @{u}');

	final int slash = _channel.indexOf('/');
	if (slash != -1) {
	final String remote = _channel.substring(0, slash);
	_repositoryUrl = _runGit('git ls-remote --get-url $remote');
	_channel = _channel.substring(slash + 1);
	} else if (_channel.isEmpty) {
	_channel = 'unknown';
	}

	_frameworkRevision = _runGit('git log -n 1 --pretty=format:%H');
	_frameworkAge = _runGit('git log -n 1 --pretty=format:%ar');
	}

	final Clock _clock;

	String _repositoryUrl;
	String get repositoryUrl => _repositoryUrl;

	String _channel;
	/// `master`, `alpha`, `hackathon`, ...
	String get channel => _channel;

	String _frameworkRevision;
	String get frameworkRevision => _frameworkRevision;
	String get frameworkRevisionShort => _shortGitRevision(frameworkRevision);

	String _frameworkAge;
	String get frameworkAge => _frameworkAge;

	String get frameworkDate => frameworkCommitDate;

	String get dartSdkVersion => Cache.dartSdkVersion.split(' ')[0];

	String get engineRevision => Cache.engineRevision;
	String get engineRevisionShort => _shortGitRevision(engineRevision);

	String _runGit(String command) => runSync(command.split(' '), workingDirectory: Cache.flutterRoot);

	@override
	String toString() {
	final String flutterText = 'Flutter • channel $channel • ${repositoryUrl == null ? 'unknown source' : repositoryUrl}';
	final String frameworkText = 'Framework • revision $frameworkRevisionShort ($frameworkAge) • $frameworkCommitDate';
	final String engineText = 'Engine • revision $engineRevisionShort';
	final String toolsText = 'Tools • Dart $dartSdkVersion';

	// Flutter • channel master • https://github.com/flutter/flutter.git
	// Framework • revision 2259c59be8 • 19 minutes ago • 2016-08-15 22:51:40
	// Engine • revision fe509b0d96
	// Tools • Dart 1.19.0-dev.5.0

	return '$flutterText\n$frameworkText\n$engineText\n$toolsText';
	}

	Map<String, Object> toJson() => <String, Object>{
	'channel': channel,
	'repositoryUrl': repositoryUrl ?? 'unknown source',
	'frameworkRevision': frameworkRevision,
	'frameworkCommitDate': frameworkCommitDate,
	'engineRevision': engineRevision,
	'dartSdkVersion': dartSdkVersion,
	};

	/// A date String describing the last framework commit.
	String get frameworkCommitDate => _latestGitCommitDate();

	static String _latestGitCommitDate([String branch]) {
	final List<String> args = <String>['git', 'log'];

	if (branch != null)
	args.add(branch);

	args.addAll(<String>['-n', '1', '--pretty=format:%ad', '--date=iso']);
	return _runSync(args, lenient: false);
	}

	/// The name of the temporary git remote used to check for the latest
	/// available Flutter framework version.
	///
	/// In the absence of bugs and crashes a Flutter developer should never see
	/// this remote appear in their `git remote` list, but also if it happens to
	/// persist we do the proper clean-up for extra robustness.
	static const String _kVersionCheckRemote = '__flutter_version_check__';

	/// The date of the latest framework commit in the remote repository.
	///
	/// Throws [ToolExit] if a git command fails, for example, when the remote git
	/// repository is not reachable due to a network issue.
	static Future<String> fetchRemoteFrameworkCommitDate(String branch) async {
	await _removeVersionCheckRemoteIfExists();
	try {
	await _run(<String>[
	'git',
	'remote',
	'add',
	_kVersionCheckRemote,
	'https://github.com/flutter/flutter.git',
	]);
	await _run(<String>['git', 'fetch', _kVersionCheckRemote, branch]);
	return _latestGitCommitDate('$_kVersionCheckRemote/$branch');
	} finally {
	await _removeVersionCheckRemoteIfExists();
	}
	}

	static Future<Null> _removeVersionCheckRemoteIfExists() async {
	final List<String> remotes = (await _run(<String>['git', 'remote']))
	.split('\n')
	.map((String name) => name.trim()) // to account for OS-specific line-breaks
	.toList();
	if (remotes.contains(_kVersionCheckRemote))
	await _run(<String>['git', 'remote', 'remove', _kVersionCheckRemote]);
	}

	static FlutterVersion get instance => context.putIfAbsent(FlutterVersion, () => new FlutterVersion(const Clock()));

	/// Return a short string for the version (`alpha/a76bc8e22b`).
	static String getVersionString({ bool whitelistBranchName: false }) {
	String commit = _shortGitRevision(_runSync(<String>['git', 'rev-parse', 'HEAD']));
	commit = commit.isEmpty ? 'unknown' : commit;

	String branch = _runSync(<String>['git', 'rev-parse', '--abbrev-ref', 'HEAD']);
	branch = branch == 'HEAD' ? 'master' : branch;

	if (whitelistBranchName \|\| branch.isEmpty) {
	// Only return the branch names we know about; arbitrary branch names might contain PII.
	if (!kKnownBranchNames.contains(branch))
	branch = 'dev';
	}

	return '$branch/$commit';
	}

	/// The amount of time we wait before pinging the server to check for the
	/// availability of a newer version of Flutter.
	@visibleForTesting
	static const Duration kCheckAgeConsideredUpToDate = const Duration(days: 7);

	/// We warn the user if the age of their Flutter installation is greater than
	/// this duration.
	@visibleForTesting
	static final Duration kVersionAgeConsideredUpToDate = kCheckAgeConsideredUpToDate * 4;

	/// The amount of time we wait between issuing a warning.
	///
	/// This is to avoid annoying users who are unable to upgrade right away.
	@visibleForTesting
	static const Duration kMaxTimeSinceLastWarning = const Duration(days: 1);

	/// The amount of time we pause for to let the user read the message about
	/// outdated Flutter installation.
	///
	/// This can be customized in tests to speed them up.
	@visibleForTesting
	static Duration kPauseToLetUserReadTheMessage = const Duration(seconds: 2);

	/// Checks if the currently installed version of Flutter is up-to-date, and
	/// warns the user if it isn't.
	///
	/// This function must run while [Cache.lock] is acquired because it reads and
	/// writes shared cache files.
	Future<Null> checkFlutterVersionFreshness() async {
	final DateTime localFrameworkCommitDate = DateTime.parse(frameworkCommitDate);
	final Duration frameworkAge = _clock.now().difference(localFrameworkCommitDate);
	final bool installationSeemsOutdated = frameworkAge > kVersionAgeConsideredUpToDate;

	Future<bool> newerFrameworkVersionAvailable() async {
	final DateTime latestFlutterCommitDate = await _getLatestAvailableFlutterVersion();

	if (latestFlutterCommitDate == null)
	return false;

	return latestFlutterCommitDate.isAfter(localFrameworkCommitDate);
	}

	final VersionCheckStamp stamp = await VersionCheckStamp.load();
	final DateTime lastTimeWarningWasPrinted = stamp.lastTimeWarningWasPrinted ?? _clock.agoBy(kMaxTimeSinceLastWarning * 2);
	final bool beenAWhileSinceWarningWasPrinted = _clock.now().difference(lastTimeWarningWasPrinted) > kMaxTimeSinceLastWarning;

	if (beenAWhileSinceWarningWasPrinted && installationSeemsOutdated && await newerFrameworkVersionAvailable()) {
	printStatus(versionOutOfDateMessage(frameworkAge), emphasis: true);
	final Future<Null> saveWarningStampFuture = stamp.store(
	newTimeWarningWasPrinted: _clock.now(),
	);
	await Future.wait<Null>(<Future<Null>>[
	saveWarningStampFuture,
	new Future<Null>.delayed(kPauseToLetUserReadTheMessage),
	]);
	}
	}

	@visibleForTesting
	static String versionOutOfDateMessage(Duration frameworkAge) {
	String warning = 'WARNING: your installation of Flutter is ${frameworkAge.inDays} days old.';
	// Append enough spaces to match the message box width.
	warning += ' ' * (74 - warning.length);

	return '''
	╔════════════════════════════════════════════════════════════════════════════╗
	║ $warning ║
	║ ║
	║ To update to the latest version, run "flutter upgrade". ║
	╚════════════════════════════════════════════════════════════════════════════╝
	''';
	}

	/// Gets the release date of the latest available Flutter version.
	///
	/// This method sends a server request if it's been more than
	/// [kCheckAgeConsideredUpToDate] since the last version check.
	///
	/// Returns null if the cached version is out-of-date or missing, and we are
	/// unable to reach the server to get the latest version.
	Future<DateTime> _getLatestAvailableFlutterVersion() async {
	Cache.checkLockAcquired();
	final VersionCheckStamp versionCheckStamp = await VersionCheckStamp.load();

	if (versionCheckStamp.lastTimeVersionWasChecked != null) {
	final Duration timeSinceLastCheck = _clock.now().difference(versionCheckStamp.lastTimeVersionWasChecked);

	// Don't ping the server too often. Return cached value if it's fresh.
	if (timeSinceLastCheck < kCheckAgeConsideredUpToDate)
	return versionCheckStamp.lastKnownRemoteVersion;
	}

	// Cache is empty or it's been a while since the last server ping. Ping the server.
	try {
	final String branch = _channel == 'alpha' ? 'alpha' : 'master';
	final DateTime remoteFrameworkCommitDate = DateTime.parse(await FlutterVersion.fetchRemoteFrameworkCommitDate(branch));
	// fire and forget since nothing subsequent depends on it. Hope there's a flush/sync mechanism.
	// ignore: unawaited_futures
	versionCheckStamp.store(
	newTimeVersionWasChecked: _clock.now(),
	newKnownRemoteVersion: remoteFrameworkCommitDate,
	);
	return remoteFrameworkCommitDate;
	} on VersionCheckError catch (error) {
	// This happens when any of the git commands fails, which can happen when
	// there's no Internet connectivity. Remote version check is best effort
	// only. We do not prevent the command from running when it fails.
	printTrace('Failed to check Flutter version in the remote repository: $error');
	return null;
	}
	}
	}

	/// Contains data and load/save logic pertaining to Flutter version checks.
	@visibleForTesting
	class VersionCheckStamp {
	/// The prefix of the stamp file where we cache Flutter version check data.
	@visibleForTesting
	static const String kFlutterVersionCheckStampFile = 'flutter_version_check';

	const VersionCheckStamp({
	this.lastTimeVersionWasChecked,
	this.lastKnownRemoteVersion,
	this.lastTimeWarningWasPrinted,
	});

	final DateTime lastTimeVersionWasChecked;
	final DateTime lastKnownRemoteVersion;
	final DateTime lastTimeWarningWasPrinted;

	static Future<VersionCheckStamp> load() async {
	final String versionCheckStamp = Cache.instance.getStampFor(kFlutterVersionCheckStampFile);

	if (versionCheckStamp != null) {
	// Attempt to parse stamp JSON.
	try {
	final dynamic json = JSON.decode(versionCheckStamp);
	if (json is Map) {
	return fromJson(json);
	} else {
	printTrace('Warning: expected version stamp to be a Map but found: $json');
	}
	} catch (error, stackTrace) {
	// Do not crash if JSON is malformed.
	printTrace('${error.runtimeType}: $error\n$stackTrace');
	}
	}

	// Stamp is missing or is malformed.
	return const VersionCheckStamp();
	}

	static VersionCheckStamp fromJson(Map<String, String> json) {
	DateTime readDateTime(String property) {
	return json.containsKey(property)
	? DateTime.parse(json[property])
	: null;
	}

	return new VersionCheckStamp(
	lastTimeVersionWasChecked: readDateTime('lastTimeVersionWasChecked'),
	lastKnownRemoteVersion: readDateTime('lastKnownRemoteVersion'),
	lastTimeWarningWasPrinted: readDateTime('lastTimeWarningWasPrinted'),
	);
	}

	Future<Null> store({
	DateTime newTimeVersionWasChecked,
	DateTime newKnownRemoteVersion,
	DateTime newTimeWarningWasPrinted,
	}) async {
	final Map<String, String> jsonData = toJson();

	if (newTimeVersionWasChecked != null)
	jsonData['lastTimeVersionWasChecked'] = '$newTimeVersionWasChecked';

	if (newKnownRemoteVersion != null)
	jsonData['lastKnownRemoteVersion'] = '$newKnownRemoteVersion';

	if (newTimeWarningWasPrinted != null)
	jsonData['lastTimeWarningWasPrinted'] = '$newTimeWarningWasPrinted';

	const JsonEncoder kPrettyJsonEncoder = const JsonEncoder.withIndent(' ');
	Cache.instance.setStampFor(kFlutterVersionCheckStampFile, kPrettyJsonEncoder.convert(jsonData));
	}

	Map<String, String> toJson({
	DateTime updateTimeVersionWasChecked,
	DateTime updateKnownRemoteVersion,
	DateTime updateTimeWarningWasPrinted,
	}) {
	updateTimeVersionWasChecked = updateTimeVersionWasChecked ?? lastTimeVersionWasChecked;
	updateKnownRemoteVersion = updateKnownRemoteVersion ?? lastKnownRemoteVersion;
	updateTimeWarningWasPrinted = updateTimeWarningWasPrinted ?? lastTimeWarningWasPrinted;

	final Map<String, String> jsonData = <String, String>{};

	if (updateTimeVersionWasChecked != null)
	jsonData['lastTimeVersionWasChecked'] = '$updateTimeVersionWasChecked';

	if (updateKnownRemoteVersion != null)
	jsonData['lastKnownRemoteVersion'] = '$updateKnownRemoteVersion';

	if (updateTimeWarningWasPrinted != null)
	jsonData['lastTimeWarningWasPrinted'] = '$updateTimeWarningWasPrinted';

	return jsonData;
	}
	}

	/// Thrown when we fail to check Flutter version.
	///
	/// This can happen when we attempt to `git fetch` but there is no network, or
	/// when the installation is not git-based (e.g. a user clones the repo but
	/// then removes .git).
	class VersionCheckError implements Exception {

	VersionCheckError(this.message);

	final String message;

	@override
	String toString() => '$VersionCheckError: $message';
	}

	/// Runs [command] and returns the standard output as a string.
	///
	/// If [lenient] is `true` and the command fails, returns an empty string.
	/// Otherwise, throws a [ToolExit] exception.
	String _runSync(List<String> command, {bool lenient: true}) {
	final ProcessResult results = processManager.runSync(command, workingDirectory: Cache.flutterRoot);

	if (results.exitCode == 0)
	return results.stdout.trim();

	if (!lenient) {
	throw new VersionCheckError(
	'Command exited with code ${results.exitCode}: ${command.join(' ')}\n'
	'Standard error: ${results.stderr}'
	);
	}

	return '';
	}

	/// Runs [command] in the root of the Flutter installation and returns the
	/// standard output as a string.
	///
	/// If the command fails, throws a [ToolExit] exception.
	Future<String> _run(List<String> command) async {
	final ProcessResult results = await processManager.run(command, workingDirectory: Cache.flutterRoot);

	if (results.exitCode == 0)
	return results.stdout.trim();

	throw new VersionCheckError(
	'Command exited with code ${results.exitCode}: ${command.join(' ')}\n'
	'Standard error: ${results.stderr}'
	);
	}

	String _shortGitRevision(String revision) {
	if (revision == null)
	return '';
	return revision.length > 10 ? revision.substring(0, 10) : revision;
	}