blob: 64c052fb8531f7d87e1f71f4744b942caf3249bf [file] [log] [blame]
// 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 jsonDecode;
import 'dart:io' as io;
import 'package:file/file.dart';
import 'package:meta/meta.dart';
import 'package:platform/platform.dart';
import 'package:process/process.dart';
import './git.dart';
import './globals.dart';
import './stdio.dart';
import './version.dart';
/// Allowed git remote names.
enum RemoteName {
upstream,
mirror,
}
class Remote {
const Remote({
required RemoteName name,
required this.url,
}) : _name = name;
final RemoteName _name;
/// The name of the remote.
String get name {
switch (_name) {
case RemoteName.upstream:
return 'upstream';
case RemoteName.mirror:
return 'mirror';
}
}
/// The URL of the remote.
final String url;
}
/// A source code repository.
abstract class Repository {
Repository({
required this.name,
required this.fetchRemote,
required this.processManager,
required this.stdio,
required this.platform,
required this.fileSystem,
required this.parentDirectory,
this.initialRef,
this.localUpstream = false,
this.useExistingCheckout = false,
this.pushRemote,
}) : git = Git(processManager),
assert(localUpstream != null),
assert(useExistingCheckout != null);
final String name;
final Remote fetchRemote;
/// Remote to publish tags and commits to.
///
/// This value can be null, in which case attempting to publish will lead to
/// a [ConductorException].
final Remote? pushRemote;
/// The initial ref (branch or commit name) to check out.
final String? initialRef;
final Git git;
final ProcessManager processManager;
final Stdio stdio;
final Platform platform;
final FileSystem fileSystem;
final Directory parentDirectory;
final bool useExistingCheckout;
/// If the repository will be used as an upstream for a test repo.
final bool localUpstream;
Directory? _checkoutDirectory;
/// Directory for the repository checkout.
///
/// Since cloning a repository takes a long time, we do not ensure it is
/// cloned on the filesystem until this getter is accessed.
Directory get checkoutDirectory {
if (_checkoutDirectory != null) {
return _checkoutDirectory!;
}
_checkoutDirectory = parentDirectory.childDirectory(name);
lazilyInitialize(_checkoutDirectory!);
return _checkoutDirectory!;
}
/// Ensure the repository is cloned to disk and initialized with proper state.
void lazilyInitialize(Directory checkoutDirectory) {
if (!useExistingCheckout && checkoutDirectory.existsSync()) {
stdio.printTrace('Deleting $name from ${checkoutDirectory.path}...');
checkoutDirectory.deleteSync(recursive: true);
}
if (!checkoutDirectory.existsSync()) {
stdio.printTrace(
'Cloning $name from ${fetchRemote.url} to ${checkoutDirectory.path}...',
);
git.run(
<String>[
'clone',
'--origin',
fetchRemote.name,
'--',
fetchRemote.url,
checkoutDirectory.path
],
'Cloning $name repo',
workingDirectory: parentDirectory.path,
);
if (pushRemote != null) {
git.run(
<String>['remote', 'add', pushRemote!.name, pushRemote!.url],
'Adding remote ${pushRemote!.url} as ${pushRemote!.name}',
workingDirectory: checkoutDirectory.path,
);
git.run(
<String>['fetch', pushRemote!.name],
'Fetching git remote ${pushRemote!.name}',
workingDirectory: checkoutDirectory.path,
);
}
if (localUpstream) {
// These branches must exist locally for the repo that depends on it
// to fetch and push to.
for (final String channel in kReleaseChannels) {
git.run(
<String>['checkout', channel, '--'],
'check out branch $channel locally',
workingDirectory: checkoutDirectory.path,
);
}
}
}
if (initialRef != null) {
git.run(
<String>['checkout', '${fetchRemote.name}/$initialRef'],
'Checking out initialRef $initialRef',
workingDirectory: checkoutDirectory.path,
);
}
final String revision = reverseParse('HEAD');
stdio.printTrace(
'Repository $name is checked out at revision "$revision".',
);
}
/// The URL of the remote named [remoteName].
String remoteUrl(String remoteName) {
assert(remoteName != null);
return git.getOutput(
<String>['remote', 'get-url', remoteName],
'verify the URL of the $remoteName remote',
workingDirectory: checkoutDirectory.path,
);
}
/// Verify the repository's git checkout is clean.
bool gitCheckoutClean() {
final String output = git.getOutput(
<String>['status', '--porcelain'],
'check that the git checkout is clean',
workingDirectory: checkoutDirectory.path,
);
return output == '';
}
/// Return the revision for the branch point between two refs.
String branchPoint(String firstRef, String secondRef) {
return git.getOutput(
<String>['merge-base', firstRef, secondRef],
'determine the merge base between $firstRef and $secondRef',
workingDirectory: checkoutDirectory.path,
).trim();
}
/// Fetch all branches and associated commits and tags from [remoteName].
void fetch(String remoteName) {
git.run(
<String>['fetch', remoteName, '--tags'],
'fetch $remoteName --tags',
workingDirectory: checkoutDirectory.path,
);
}
/// Create (and checkout) a new branch based on the current HEAD.
///
/// Runs `git checkout -b $branchName`.
void newBranch(String branchName) {
git.run(
<String>['checkout', '-b', branchName],
'create & checkout new branch $branchName',
workingDirectory: checkoutDirectory.path,
);
}
/// Check out the given ref.
void checkout(String ref) {
git.run(
<String>['checkout', ref],
'checkout ref',
workingDirectory: checkoutDirectory.path,
);
}
/// Obtain the version tag of the previous dev release.
String getFullTag(String remoteName) {
const String glob = '*.*.*-*.*.pre';
// describe the latest dev release
final String ref = 'refs/remotes/$remoteName/dev';
return git.getOutput(
<String>['describe', '--match', glob, '--exact-match', '--tags', ref],
'obtain last released version number',
workingDirectory: checkoutDirectory.path,
);
}
/// List commits in reverse chronological order.
List<String> revList(List<String> args) {
return git
.getOutput(
<String>['rev-list', ...args],
'rev-list with args ${args.join(' ')}',
workingDirectory: checkoutDirectory.path,
)
.trim()
.split('\n');
}
/// Look up the commit for [ref].
String reverseParse(String ref) {
final String revisionHash = git.getOutput(
<String>['rev-parse', ref],
'look up the commit for the ref $ref',
workingDirectory: checkoutDirectory.path,
);
assert(revisionHash.isNotEmpty);
return revisionHash;
}
/// Determines if one ref is an ancestor for another.
bool isAncestor(String possibleAncestor, String possibleDescendant) {
final int exitcode = git.run(
<String>[
'merge-base',
'--is-ancestor',
possibleDescendant,
possibleAncestor
],
'verify $possibleAncestor is a direct ancestor of $possibleDescendant.',
allowNonZeroExitCode: true,
workingDirectory: checkoutDirectory.path,
);
return exitcode == 0;
}
/// Determines if a given commit has a tag.
bool isCommitTagged(String commit) {
final int exitcode = git.run(
<String>['describe', '--exact-match', '--tags', commit],
'verify $commit is already tagged',
allowNonZeroExitCode: true,
workingDirectory: checkoutDirectory.path,
);
return exitcode == 0;
}
/// Determines if a commit will cherry-pick to current HEAD without conflict.
bool canCherryPick(String commit) {
assert(
gitCheckoutClean(),
'cannot cherry-pick because git checkout ${checkoutDirectory.path} is not clean',
);
final int exitcode = git.run(
<String>['cherry-pick', '--no-commit', commit],
'attempt to cherry-pick $commit without committing',
allowNonZeroExitCode: true,
workingDirectory: checkoutDirectory.path,
);
final bool result = exitcode == 0;
if (result == false) {
stdio.printError(git.getOutput(
<String>['diff'],
'get diff of failed cherry-pick',
workingDirectory: checkoutDirectory.path,
));
}
reset('HEAD');
return result;
}
/// Cherry-pick a [commit] to the current HEAD.
///
/// This method will throw a [GitException] if the command fails.
void cherryPick(String commit) {
assert(
gitCheckoutClean(),
'cannot cherry-pick because git checkout ${checkoutDirectory.path} is not clean',
);
git.run(
<String>['cherry-pick', commit],
'cherry-pick $commit',
workingDirectory: checkoutDirectory.path,
);
}
/// Resets repository HEAD to [ref].
void reset(String ref) {
git.run(
<String>['reset', ref, '--hard'],
'reset to $ref',
workingDirectory: checkoutDirectory.path,
);
}
/// Tag [commit] and push the tag to the remote.
void tag(String commit, String tagName, String remote) {
git.run(
<String>['tag', tagName, commit],
'tag the commit with the version label',
workingDirectory: checkoutDirectory.path,
);
git.run(
<String>['push', remote, tagName],
'publish the tag to the repo',
workingDirectory: checkoutDirectory.path,
);
}
/// Push [commit] to the release channel [branch].
void updateChannel(
String commit,
String remote,
String branch, {
bool force = false,
}) {
git.run(
<String>[
'push',
if (force) '--force',
remote,
'$commit:$branch',
],
'update the release branch with the commit',
workingDirectory: checkoutDirectory.path,
);
}
/// Create an empty commit and return the revision.
@visibleForTesting
String authorEmptyCommit([String message = 'An empty commit']) {
git.run(
<String>[
'-c',
'user.name=Conductor',
'-c',
'user.email=conductor@flutter.dev',
'commit',
'--allow-empty',
'-m',
'\'$message\'',
],
'create an empty commit',
workingDirectory: checkoutDirectory.path,
);
return reverseParse('HEAD');
}
/// Create a new clone of the current repository.
///
/// The returned repository will inherit all properties from this one, except
/// for the upstream, which will be the path to this repository on disk.
///
/// This method is for testing purposes.
@visibleForTesting
Repository cloneRepository(String cloneName);
}
class FrameworkRepository extends Repository {
FrameworkRepository(
this.checkouts, {
String name = 'framework',
Remote fetchRemote = const Remote(
name: RemoteName.upstream, url: FrameworkRepository.defaultUpstream),
bool localUpstream = false,
bool useExistingCheckout = false,
String? initialRef,
Remote? pushRemote,
}) : super(
name: name,
fetchRemote: fetchRemote,
pushRemote: pushRemote,
initialRef: initialRef,
fileSystem: checkouts.fileSystem,
localUpstream: localUpstream,
parentDirectory: checkouts.directory,
platform: checkouts.platform,
processManager: checkouts.processManager,
stdio: checkouts.stdio,
useExistingCheckout: useExistingCheckout,
);
/// A [FrameworkRepository] with the host conductor's repo set as upstream.
///
/// This is useful when testing a commit that has not been merged upstream
/// yet.
factory FrameworkRepository.localRepoAsUpstream(
Checkouts checkouts, {
String name = 'framework',
bool useExistingCheckout = false,
required String upstreamPath,
}) {
return FrameworkRepository(
checkouts,
name: name,
fetchRemote: Remote(
name: RemoteName.upstream,
url: 'file://$upstreamPath/',
),
localUpstream: false,
useExistingCheckout: useExistingCheckout,
);
}
final Checkouts checkouts;
static const String defaultUpstream =
'https://github.com/flutter/flutter.git';
static const String defaultBranch = 'master';
String get cacheDirectory => fileSystem.path.join(
checkoutDirectory.path,
'bin',
'cache',
);
@override
Repository cloneRepository(String? cloneName) {
assert(localUpstream);
cloneName ??= 'clone-of-$name';
return FrameworkRepository(
checkouts,
name: cloneName,
fetchRemote: Remote(
name: RemoteName.upstream, url: 'file://${checkoutDirectory.path}/'),
useExistingCheckout: useExistingCheckout,
);
}
void _ensureToolReady() {
final File toolsStamp =
fileSystem.directory(cacheDirectory).childFile('flutter_tools.stamp');
if (toolsStamp.existsSync()) {
final String toolsStampHash = toolsStamp.readAsStringSync().trim();
final String repoHeadHash = reverseParse('HEAD');
if (toolsStampHash == repoHeadHash) {
return;
}
}
stdio.printTrace('Building tool...');
// Build tool
processManager.runSync(<String>[
fileSystem.path.join(checkoutDirectory.path, 'bin', 'flutter'),
'help',
]);
}
io.ProcessResult runFlutter(List<String> args) {
_ensureToolReady();
return processManager.runSync(<String>[
fileSystem.path.join(checkoutDirectory.path, 'bin', 'flutter'),
...args,
]);
}
@override
void checkout(String ref) {
super.checkout(ref);
// The tool will overwrite old cached artifacts, but not delete unused
// artifacts from a previous version. Thus, delete the entire cache and
// re-populate.
final Directory cache = fileSystem.directory(cacheDirectory);
if (cache.existsSync()) {
stdio.printTrace('Deleting cache...');
cache.deleteSync(recursive: true);
}
_ensureToolReady();
}
Version flutterVersion() {
// Check version
final io.ProcessResult result =
runFlutter(<String>['--version', '--machine']);
final Map<String, dynamic> versionJson = jsonDecode(
stdoutToString(result.stdout),
) as Map<String, dynamic>;
return Version.fromString(versionJson['frameworkVersion'] as String);
}
}
/// A wrapper around the host repository that is executing the conductor.
///
/// [Repository] methods that mutate the underlying repository will throw a
/// [ConductorException].
class HostFrameworkRepository extends FrameworkRepository {
HostFrameworkRepository({
required Checkouts checkouts,
String name = 'host-framework',
bool useExistingCheckout = false,
required String upstreamPath,
}) : super(
checkouts,
name: name,
fetchRemote: Remote(
name: RemoteName.upstream,
url: 'file://$upstreamPath/',
),
localUpstream: false,
useExistingCheckout: useExistingCheckout,
) {
_checkoutDirectory = checkouts.fileSystem.directory(upstreamPath);
}
@override
Directory get checkoutDirectory => _checkoutDirectory!;
@override
void newBranch(String branchName) {
throw ConductorException('newBranch not implemented for the host repository');
}
@override
void checkout(String ref) {
throw ConductorException('checkout not implemented for the host repository');
}
@override
String cherryPick(String commit) {
throw ConductorException('cherryPick not implemented for the host repository');
}
@override
String reset(String ref) {
throw ConductorException('reset not implemented for the host repository');
}
@override
void tag(String commit, String tagName, String remote) {
throw ConductorException('tag not implemented for the host repository');
}
@override
void updateChannel(
String commit,
String remote,
String branch, {
bool force = false,
}) {
throw ConductorException('updateChannel not implemented for the host repository');
}
@override
String authorEmptyCommit([String message = 'An empty commit']) {
throw ConductorException(
'authorEmptyCommit not implemented for the host repository',
);
}
}
class EngineRepository extends Repository {
EngineRepository(
this.checkouts, {
String name = 'engine',
String initialRef = EngineRepository.defaultBranch,
Remote fetchRemote = const Remote(
name: RemoteName.upstream, url: EngineRepository.defaultUpstream),
bool localUpstream = false,
bool useExistingCheckout = false,
Remote? pushRemote,
}) : super(
name: name,
fetchRemote: fetchRemote,
pushRemote: pushRemote,
initialRef: initialRef,
fileSystem: checkouts.fileSystem,
localUpstream: localUpstream,
parentDirectory: checkouts.directory,
platform: checkouts.platform,
processManager: checkouts.processManager,
stdio: checkouts.stdio,
useExistingCheckout: useExistingCheckout,
);
final Checkouts checkouts;
static const String defaultUpstream = 'https://github.com/flutter/engine.git';
static const String defaultBranch = 'master';
@override
Repository cloneRepository(String? cloneName) {
assert(localUpstream);
cloneName ??= 'clone-of-$name';
return EngineRepository(
checkouts,
name: cloneName,
fetchRemote: Remote(
name: RemoteName.upstream, url: 'file://${checkoutDirectory.path}/'),
useExistingCheckout: useExistingCheckout,
);
}
}
/// An enum of all the repositories that the Conductor supports.
enum RepositoryType {
framework,
engine,
}
class Checkouts {
Checkouts({
required this.fileSystem,
required this.platform,
required this.processManager,
required this.stdio,
required Directory parentDirectory,
String directoryName = 'flutter_conductor_checkouts',
}) : directory = parentDirectory.childDirectory(directoryName) {
if (!directory.existsSync()) {
directory.createSync(recursive: true);
}
}
final Directory directory;
final FileSystem fileSystem;
final Platform platform;
final ProcessManager processManager;
final Stdio stdio;
}