utils.dart 24 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3 4 5 6 7
// 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 'dart:io';
8
import 'dart:math' as math;
9

10
import 'package:flutter_devicelab/framework/adb.dart';
11 12
import 'package:meta/meta.dart';
import 'package:path/path.dart' as path;
13
import 'package:process/process.dart';
14 15
import 'package:stack_trace/stack_trace.dart';

16
import 'task_result.dart';
17

18 19 20
/// Virtual current working directory, which affect functions, such as [exec].
String cwd = Directory.current.path;

21
/// The local engine to use for [flutter] and [evalFlutter], if any.
22 23 24 25 26 27 28 29
String get localEngine {
  // Use two distinct `defaultValue`s to determine whether a 'localEngine'
  // declaration exists in the environment.
  const bool isDefined =
      String.fromEnvironment('localEngine', defaultValue: 'a') ==
          String.fromEnvironment('localEngine', defaultValue: 'b');
  return isDefined ? const String.fromEnvironment('localEngine') : null;
}
30 31 32

/// The local engine source path to use if a local engine is used for [flutter]
/// and [evalFlutter].
33 34 35 36 37 38 39 40
String get localEngineSrcPath {
  // Use two distinct `defaultValue`s to determine whether a
  // 'localEngineSrcPath' declaration exists in the environment.
  const bool isDefined =
      String.fromEnvironment('localEngineSrcPath', defaultValue: 'a') ==
          String.fromEnvironment('localEngineSrcPath', defaultValue: 'b');
  return isDefined ? const String.fromEnvironment('localEngineSrcPath') : null;
}
41

42
List<ProcessInfo> _runningProcesses = <ProcessInfo>[];
43
ProcessManager _processManager = const LocalProcessManager();
44 45 46 47

class ProcessInfo {
  ProcessInfo(this.command, this.process);

48
  final DateTime startTime = DateTime.now();
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
  final String command;
  final Process process;

  @override
  String toString() {
    return '''
  command : $command
  started : $startTime
  pid     : ${process.pid}
'''
        .trim();
  }
}

/// Result of a health check for a specific parameter.
class HealthCheckResult {
  HealthCheckResult.success([this.details]) : succeeded = true;
  HealthCheckResult.failure(this.details) : succeeded = false;
  HealthCheckResult.error(dynamic error, dynamic stackTrace)
      : succeeded = false,
        details = 'ERROR: $error${'\n$stackTrace' ?? ''}';

  final bool succeeded;
  final String details;

  @override
  String toString() {
76
    final StringBuffer buf = StringBuffer(succeeded ? 'succeeded' : 'failed');
77 78 79
    if (details != null && details.trim().isNotEmpty) {
      buf.writeln();
      // Indent details by 4 spaces
80
      for (final String line in details.trim().split('\n')) {
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
        buf.writeln('    $line');
      }
    }
    return '$buf';
  }
}

class BuildFailedError extends Error {
  BuildFailedError(this.message);

  final String message;

  @override
  String toString() => message;
}

void fail(String message) {
98
  throw BuildFailedError(message);
99 100
}

101 102 103 104 105 106 107 108 109 110 111 112
// Remove the given file or directory.
void rm(FileSystemEntity entity, { bool recursive = false}) {
  if (entity.existsSync()) {
    // This should not be necessary, but it turns out that
    // on Windows it's common for deletions to fail due to
    // bogus (we think) "access denied" errors.
    try {
      entity.deleteSync(recursive: recursive);
    } on FileSystemException catch (error) {
      print('Failed to delete ${entity.path}: $error');
    }
  }
113 114 115 116
}

/// Remove recursively.
void rmTree(FileSystemEntity entity) {
117
  rm(entity, recursive: true);
118 119 120 121
}

List<FileSystemEntity> ls(Directory directory) => directory.listSync();

122
Directory dir(String path) => Directory(path);
123

124
File file(String path) => File(path);
125 126

void copy(File sourceFile, Directory targetDirectory, {String name}) {
127
  final File target = file(
128 129 130 131
      path.join(targetDirectory.path, name ?? path.basename(sourceFile.path)));
  target.writeAsBytesSync(sourceFile.readAsBytesSync());
}

132 133 134 135
void recursiveCopy(Directory source, Directory target) {
  if (!target.existsSync())
    target.createSync();

136
  for (final FileSystemEntity entity in source.listSync(followLinks: false)) {
137
    final String name = path.basename(entity.path);
138
    if (entity is Directory && !entity.path.contains('.dart_tool'))
139
      recursiveCopy(entity, Directory(path.join(target.path, name)));
140
    else if (entity is File) {
141
      final File dest = File(path.join(target.path, name));
142
      dest.writeAsBytesSync(entity.readAsBytesSync());
143 144 145 146 147
      // Preserve executable bit
      final String modes = entity.statSync().modeString();
      if (modes != null && modes.contains('x')) {
        makeExecutable(dest);
      }
148 149 150 151
    }
  }
}

152 153 154 155 156 157
FileSystemEntity move(FileSystemEntity whatToMove,
    {Directory to, String name}) {
  return whatToMove
      .renameSync(path.join(to.path, name ?? path.basename(whatToMove.path)));
}

158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
/// Equivalent of `chmod a+x file`
void makeExecutable(File file) {
  // Windows files do not have an executable bit
  if (Platform.isWindows) {
    return;
  }
  final ProcessResult result = _processManager.runSync(<String>[
    'chmod',
    'a+x',
    file.path,
  ]);

  if (result.exitCode != 0) {
    throw FileSystemException(
      'Error making ${file.path} executable.\n'
      '${result.stderr}',
      file.path,
    );
  }
}

179 180 181 182 183 184 185 186 187 188 189 190 191
/// Equivalent of `mkdir directory`.
void mkdir(Directory directory) {
  directory.createSync();
}

/// Equivalent of `mkdir -p directory`.
void mkdirs(Directory directory) {
  directory.createSync(recursive: true);
}

bool exists(FileSystemEntity entity) => entity.existsSync();

void section(String title) {
192 193 194 195 196 197 198 199 200 201 202 203
  String output;
  if (Platform.isWindows) {
    // Windows doesn't cope well with characters produced for *nix systems, so
    // just output the title with no decoration.
    output = title;
  } else {
    title = '╡ ••• $title ••• ╞';
    final String line = '═' * math.max((80 - title.length) ~/ 2, 2);
    output = '$line$title$line';
    if (output.length == 79)
      output += '═';
  }
204
  print('\n\n$output\n');
205 206 207 208
}

Future<String> getDartVersion() async {
  // The Dart VM returns the version text to stderr.
209
  final ProcessResult result = _processManager.runSync(<String>[dartBin, '--version']);
210
  String version = (result.stderr as String).trim();
211 212 213 214 215

  // Convert:
  //   Dart VM version: 1.17.0-dev.2.0 (Tue May  3 12:14:52 2016) on "macos_x64"
  // to:
  //   1.17.0-dev.2.0
216
  if (version.contains('('))
217
    version = version.substring(0, version.indexOf('(')).trim();
218
  if (version.contains(':'))
219 220 221 222 223 224 225
    version = version.substring(version.indexOf(':') + 1).trim();

  return version.replaceAll('"', "'");
}

Future<String> getCurrentFlutterRepoCommit() {
  if (!dir('${flutterDirectory.path}/.git').existsSync()) {
226
    return Future<String>.value(null);
227 228
  }

229
  return inDirectory<String>(flutterDirectory, () {
230 231 232 233 234 235
    return eval('git', <String>['rev-parse', 'HEAD']);
  });
}

Future<DateTime> getFlutterRepoCommitTimestamp(String commit) {
  // git show -s --format=%at 4b546df7f0b3858aaaa56c4079e5be1ba91fbb65
236
  return inDirectory<DateTime>(flutterDirectory, () async {
237
    final String unixTimestamp = await eval('git', <String>[
238 239 240 241 242
      'show',
      '-s',
      '--format=%at',
      commit,
    ]);
243
    final int secondsSinceEpoch = int.parse(unixTimestamp);
244
    return DateTime.fromMillisecondsSinceEpoch(secondsSinceEpoch * 1000);
245 246 247
  });
}

248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
/// Starts a subprocess.
///
/// The first argument is the full path to the executable to run.
///
/// The second argument is the list of arguments to provide on the command line.
/// This argument can be null, indicating no arguments (same as the empty list).
///
/// The `environment` argument can be provided to configure environment variables
/// that will be made available to the subprocess. The `BOT` environment variable
/// is always set and overrides any value provided in the `environment` argument.
/// The `isBot` argument controls the value of the `BOT` variable. It will either
/// be "true", if `isBot` is true (the default), or "false" if it is false.
///
/// The `BOT` variable is in particular used by the `flutter` tool to determine
/// how verbose to be and whether to enable analytics by default.
///
/// The working directory can be provided using the `workingDirectory` argument.
/// By default it will default to the current working directory (see [cwd]).
///
/// Information regarding the execution of the subprocess is printed to the
/// console.
///
/// The actual process executes asynchronously. A handle to the subprocess is
/// returned in the form of a [Future] that completes to a [Process] object.
272 273 274 275
Future<Process> startProcess(
  String executable,
  List<String> arguments, {
  Map<String, String> environment,
276
  bool isBot = true, // set to false to pretend not to be on a bot (e.g. to test user-facing outputs)
277 278
  String workingDirectory,
}) async {
279
  assert(isBot != null);
280
  final String command = '$executable ${arguments?.join(" ") ?? ""}';
281
  final String finalWorkingDirectory = workingDirectory ?? cwd;
282 283
  print('\nExecuting: $command in $finalWorkingDirectory'
      + (environment != null ? ' with environment $environment' : ''));
284 285
  final Map<String, String> newEnvironment = Map<String, String>.from(environment ?? <String, String>{});
  newEnvironment['BOT'] = isBot ? 'true' : 'false';
286
  final Process process = await _processManager.start(
287
    <String>[executable, ...arguments],
288
    environment: newEnvironment,
289
    workingDirectory: finalWorkingDirectory,
290
  );
291
  final ProcessInfo processInfo = ProcessInfo(command, process);
292 293
  _runningProcesses.add(processInfo);

294
  process.exitCode.then<void>((int exitCode) {
295
    print('"$executable" exit code: $exitCode');
296
    _runningProcesses.remove(processInfo);
297 298
  });

299
  return process;
300 301
}

302
Future<void> forceQuitRunningProcesses() async {
303 304 305 306
  if (_runningProcesses.isEmpty)
    return;

  // Give normally quitting processes a chance to report their exit code.
307
  await Future<void>.delayed(const Duration(seconds: 1));
308 309

  // Whatever's left, kill it.
310
  for (final ProcessInfo p in _runningProcesses) {
311
    print('Force-quitting process:\n$p');
312 313 314 315 316 317 318 319
    if (!p.process.kill()) {
      print('Failed to force quit process');
    }
  }
  _runningProcesses.clear();
}

/// Executes a command and returns its exit code.
320 321 322 323
Future<int> exec(
  String executable,
  List<String> arguments, {
  Map<String, String> environment,
324
  bool canFail = false, // as in, whether failures are ok. False means that they are fatal.
325
  String workingDirectory,
326
}) async {
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
  return _execute(
    executable,
    arguments,
    environment: environment,
    canFail : canFail,
    workingDirectory: workingDirectory,
  );
}

Future<int> _execute(
  String executable,
  List<String> arguments, {
  Map<String, String> environment,
  bool canFail = false, // as in, whether failures are ok. False means that they are fatal.
  String workingDirectory,
  StringBuffer output, // if not null, the stdout will be written here
  StringBuffer stderr, // if not null, the stderr will be written here
  bool printStdout = true,
  bool printStderr = true,
}) async {
  final Process process = await startProcess(
    executable,
    arguments,
    environment: environment,
    workingDirectory: workingDirectory,
  );
  await forwardStandardStreams(
    process,
    output: output,
    stderr: stderr,
    printStdout: printStdout,
    printStderr: printStderr,
    );
360 361 362 363 364 365 366
  final int exitCode = await process.exitCode;

  if (exitCode != 0 && !canFail)
    fail('Executable "$executable" failed with exit code $exitCode.');

  return exitCode;
}
367

368
/// Forwards standard out and standard error from [process] to this process'
369 370
/// respective outputs. Also writes stdout to [output] and stderr to [stderr]
/// if they are not null.
371 372
///
/// Returns a future that completes when both out and error streams a closed.
373 374 375 376 377 378 379
Future<void> forwardStandardStreams(
  Process process, {
  StringBuffer output,
  StringBuffer stderr,
  bool printStdout = true,
  bool printStderr = true,
  }) {
380 381
  final Completer<void> stdoutDone = Completer<void>();
  final Completer<void> stderrDone = Completer<void>();
382
  process.stdout
383 384
      .transform<String>(utf8.decoder)
      .transform<String>(const LineSplitter())
385
      .listen((String line) {
386 387 388 389
        if (printStdout) {
          print('stdout: $line');
        }
        output?.writeln(line);
390
      }, onDone: () { stdoutDone.complete(); });
391
  process.stderr
392 393
      .transform<String>(utf8.decoder)
      .transform<String>(const LineSplitter())
394
      .listen((String line) {
395 396 397 398
        if (printStderr) {
          print('stderr: $line');
        }
        stderr?.writeln(line);
399
      }, onDone: () { stderrDone.complete(); });
400

401 402 403 404
  return Future.wait<void>(<Future<void>>[
    stdoutDone.future,
    stderrDone.future,
  ]);
405 406 407 408
}

/// Executes a command and returns its standard output as a String.
///
409
/// For logging purposes, the command's output is also printed out by default.
410 411 412 413
Future<String> eval(
  String executable,
  List<String> arguments, {
  Map<String, String> environment,
414
  bool canFail = false, // as in, whether failures are ok. False means that they are fatal.
415
  String workingDirectory,
416
  StringBuffer stderr, // if not null, the stderr will be written here
417 418
  bool printStdout = true,
  bool printStderr = true,
419
}) async {
420
  final StringBuffer output = StringBuffer();
421 422 423 424 425 426 427 428 429 430 431
  await _execute(
    executable,
    arguments,
    environment: environment,
    canFail: canFail,
    workingDirectory: workingDirectory,
    output: output,
    stderr: stderr,
    printStdout: printStdout,
    printStderr: printStderr,
  );
432
  return output.toString().trimRight();
433 434
}

435
List<String> flutterCommandArgs(String command, List<String> options) {
436
  // Commands support the --device-timeout flag.
437
  final Set<String> supportedDeviceTimeoutCommands = <String>{
438 439 440 441 442 443 444
    'attach',
    'devices',
    'drive',
    'install',
    'logs',
    'run',
    'screenshot',
445
  };
446
  return <String>[
447
    command,
448 449 450
    if (deviceOperatingSystem == DeviceOperatingSystem.ios && supportedDeviceTimeoutCommands.contains(command))
      ...<String>[
        '--device-timeout',
451
        '5',
452
      ],
453 454 455 456
    if (localEngine != null) ...<String>['--local-engine', localEngine],
    if (localEngineSrcPath != null) ...<String>['--local-engine-src-path', localEngineSrcPath],
    ...options,
  ];
457 458
}

459 460
/// Runs the flutter `command`, and returns the exit code.
/// If `canFail` is `false`, the future completes with an error.
461 462 463
Future<int> flutter(String command, {
  List<String> options = const <String>[],
  bool canFail = false, // as in, whether failures are ok. False means that they are fatal.
464
  Map<String, String> environment = const <String, String>{},
465 466
}) {
  final List<String> args = flutterCommandArgs(command, options);
467
  return exec(path.join(flutterDirectory.path, 'bin', 'flutter'), args,
468
    canFail: canFail, environment: environment);
469 470
}

471
/// Runs a `flutter` command and returns the standard output as a string.
472
Future<String> evalFlutter(String command, {
473
  List<String> options = const <String>[],
474
  bool canFail = false, // as in, whether failures are ok. False means that they are fatal.
475
  Map<String, String> environment,
476
  StringBuffer stderr, // if not null, the stderr will be written here.
477
}) {
478
  final List<String> args = flutterCommandArgs(command, options);
479
  return eval(path.join(flutterDirectory.path, 'bin', 'flutter'), args,
480
      canFail: canFail, environment: environment, stderr: stderr);
481 482
}

483 484 485 486 487 488 489 490 491 492
Future<ProcessResult> executeFlutter(String command, {
  List<String> options = const <String>[],
}) async {
  final List<String> args = flutterCommandArgs(command, options);
  return _processManager.run(
    <String>[path.join(flutterDirectory.path, 'bin', 'flutter'), ...args],
    workingDirectory: cwd,
  );
}

493 494 495
String get dartBin =>
    path.join(flutterDirectory.path, 'bin', 'cache', 'dart-sdk', 'bin', 'dart');

496 497 498
String get pubBin =>
    path.join(flutterDirectory.path, 'bin', 'cache', 'dart-sdk', 'bin', 'pub');

499
Future<int> dart(List<String> args) => exec(dartBin, <String>['--disable-dart-dev', ...args]);
500

501 502 503 504 505 506 507 508 509 510 511 512 513 514
/// Returns a future that completes with a path suitable for JAVA_HOME
/// or with null, if Java cannot be found.
Future<String> findJavaHome() async {
  final Iterable<String> hits = grep(
    'Java binary at: ',
    from: await evalFlutter('doctor', options: <String>['-v']),
  );
  if (hits.isEmpty)
    return null;
  final String javaBinary = hits.first.split(': ').last;
  // javaBinary == /some/path/to/java/home/bin/java
  return path.dirname(path.dirname(javaBinary));
}

515
Future<T> inDirectory<T>(dynamic directory, Future<T> Function() action) async {
516
  final String previousCwd = cwd;
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
  try {
    cd(directory);
    return await action();
  } finally {
    cd(previousCwd);
  }
}

void cd(dynamic directory) {
  Directory d;
  if (directory is String) {
    cwd = directory;
    d = dir(directory);
  } else if (directory is Directory) {
    cwd = directory.path;
    d = directory;
  } else {
534
    throw FileSystemException('Unsupported directory type ${directory.runtimeType}', directory.toString());
535 536 537
  }

  if (!d.existsSync())
538
    throw FileSystemException('Cannot cd into directory that does not exist', d.toString());
539 540
}

541
Directory get flutterDirectory => Directory.current.parent.parent;
542 543

String requireEnvVar(String name) {
544
  final String value = Platform.environment[name];
545

546 547
  if (value == null)
    fail('$name environment variable is missing. Quitting.');
548 549 550 551

  return value;
}

552
T requireConfigProperty<T>(Map<String, dynamic> map, String propertyName) {
553 554
  if (!map.containsKey(propertyName))
    fail('Configuration property not found: $propertyName');
555
  final T result = map[propertyName] as T;
556
  return result;
557 558 559
}

String jsonEncode(dynamic data) {
560
  return const JsonEncoder.withIndent('  ').convert(data) + '\n';
561 562
}

563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
Future<void> getNewGallery(String revision, Directory galleryDir) async {
  section('Get New Flutter Gallery!');

  if (exists(galleryDir)) {
    galleryDir.deleteSync(recursive: true);
  }

  await inDirectory<void>(galleryDir.parent, () async {
    await exec('git', <String>['clone', 'https://github.com/flutter/gallery.git']);
  });

  await inDirectory<void>(galleryDir, () async {
    await exec('git', <String>['checkout', revision]);
  });
}

579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629
void checkNotNull(Object o1,
    [Object o2 = 1,
    Object o3 = 1,
    Object o4 = 1,
    Object o5 = 1,
    Object o6 = 1,
    Object o7 = 1,
    Object o8 = 1,
    Object o9 = 1,
    Object o10 = 1]) {
  if (o1 == null)
    throw 'o1 is null';
  if (o2 == null)
    throw 'o2 is null';
  if (o3 == null)
    throw 'o3 is null';
  if (o4 == null)
    throw 'o4 is null';
  if (o5 == null)
    throw 'o5 is null';
  if (o6 == null)
    throw 'o6 is null';
  if (o7 == null)
    throw 'o7 is null';
  if (o8 == null)
    throw 'o8 is null';
  if (o9 == null)
    throw 'o9 is null';
  if (o10 == null)
    throw 'o10 is null';
}

/// Splits [from] into lines and selects those that contain [pattern].
Iterable<String> grep(Pattern pattern, {@required String from}) {
  return from.split('\n').where((String line) {
    return line.contains(pattern);
  });
}

/// Captures asynchronous stack traces thrown by [callback].
///
/// This is a convenience wrapper around [Chain] optimized for use with
/// `async`/`await`.
///
/// Example:
///
///     try {
///       await captureAsyncStacks(() { /* async things */ });
///     } catch (error, chain) {
///
///     }
630
Future<void> runAndCaptureAsyncStacks(Future<void> Function() callback) {
631
  final Completer<void> completer = Completer<void>();
632 633 634
  Chain.capture(() async {
    await callback();
    completer.complete();
635
  }, onError: completer.completeError);
636 637
  return completer.future;
}
638

639
bool canRun(String path) => _processManager.canRun(path);
640

641 642
final RegExp _obsRegExp =
  RegExp('An Observatory debugger .* is available at: ');
643
final RegExp _obsPortRegExp = RegExp(r'(\S+:(\d+)/\S*)$');
644
final RegExp _obsUriRegExp = RegExp(r'((http|//)[a-zA-Z0-9:/=_\-\.\[\]]+)');
645

646 647 648
/// Tries to extract a port from the string.
///
/// The `prefix`, if specified, is a regular expression pattern and must not contain groups.
649
/// `prefix` defaults to the RegExp: `An Observatory debugger .* is available at: `.
650
int parseServicePort(String line, {
651
  Pattern prefix,
652
}) {
653
  prefix ??= _obsRegExp;
654 655
  final Iterable<Match> matchesIter = prefix.allMatches(line);
  if (matchesIter.isEmpty) {
656 657
    return null;
  }
658
  final Match prefixMatch = matchesIter.first;
659 660 661 662 663
  final List<Match> matches =
    _obsPortRegExp.allMatches(line, prefixMatch.end).toList();
  return matches.isEmpty ? null : int.parse(matches[0].group(2));
}

664
/// Tries to extract a URL from the string.
665 666 667 668 669 670 671
///
/// The `prefix`, if specified, is a regular expression pattern and must not contain groups.
/// `prefix` defaults to the RegExp: `An Observatory debugger .* is available at: `.
Uri parseServiceUri(String line, {
  Pattern prefix,
}) {
  prefix ??= _obsRegExp;
672 673
  final Iterable<Match> matchesIter = prefix.allMatches(line);
  if (matchesIter.isEmpty) {
674 675
    return null;
  }
676
  final Match prefixMatch = matchesIter.first;
677 678 679
  final List<Match> matches =
    _obsUriRegExp.allMatches(line, prefixMatch.end).toList();
  return matches.isEmpty ? null : Uri.parse(matches[0].group(0));
680
}
681

682 683 684
/// Checks that the file exists, otherwise throws a [FileSystemException].
void checkFileExists(String file) {
  if (!exists(File(file))) {
685
    throw FileSystemException('Expected file to exist.', file);
686 687
  }
}
688

xster's avatar
xster committed
689 690 691
/// Checks that the file does not exists, otherwise throws a [FileSystemException].
void checkFileNotExists(String file) {
  if (exists(File(file))) {
692
    throw FileSystemException('Expected file to not exist.', file);
xster's avatar
xster committed
693 694 695
  }
}

696 697 698 699 700 701 702
/// Checks that the directory exists, otherwise throws a [FileSystemException].
void checkDirectoryExists(String directory) {
  if (!exists(Directory(directory))) {
    throw FileSystemException('Expected directory to exist.', directory);
  }
}

703 704 705 706 707 708 709
/// Checks that the directory does not exist, otherwise throws a [FileSystemException].
void checkDirectoryNotExists(String directory) {
  if (exists(Directory(directory))) {
    throw FileSystemException('Expected directory to not exist.', directory);
  }
}

710 711
/// Check that `collection` contains all entries in `values`.
void checkCollectionContains<T>(Iterable<T> values, Iterable<T> collection) {
712
  for (final T value in values) {
713 714 715
    if (!collection.contains(value)) {
      throw TaskResult.failure('Expected to find `$value` in `${collection.toString()}`.');
    }
716 717 718
  }
}

719 720
/// Check that `collection` does not contain any entries in `values`
void checkCollectionDoesNotContain<T>(Iterable<T> values, Iterable<T> collection) {
721
  for (final T value in values) {
722 723 724 725
    if (collection.contains(value)) {
      throw TaskResult.failure('Did not expect to find `$value` in `$collection`.');
    }
  }
726 727
}

728 729 730 731
/// Checks that the contents of a [File] at `filePath` contains the specified
/// [Pattern]s, otherwise throws a [TaskResult].
void checkFileContains(List<Pattern> patterns, String filePath) {
  final String fileContent = File(filePath).readAsStringSync();
732
  for (final Pattern pattern in patterns) {
733 734 735 736 737 738 739
    if (!fileContent.contains(pattern)) {
      throw TaskResult.failure(
        'Expected to find `$pattern` in `$filePath` '
        'instead it found:\n$fileContent'
      );
    }
  }
740
}
741 742 743 744 745 746 747 748 749 750

/// Clones a git repository.
///
/// Removes the directory [path], then clones the git repository
/// specified by [repo] to the directory [path].
Future<int> gitClone({String path, String repo}) async {
  rmTree(Directory(path));

  await Directory(path).create(recursive: true);

751
  return inDirectory<int>(
752 753 754 755
    path,
        () => exec('git', <String>['clone', repo]),
  );
}
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786

/// Call [fn] retrying so long as [retryIf] return `true` for the exception
/// thrown and [maxAttempts] has not been reached.
///
/// If no [retryIf] function is given this will retry any for any [Exception]
/// thrown. To retry on an [Error], the error must be caught and _rethrown_
/// as an [Exception].
///
/// Waits a constant duration of [delayDuration] between every retry attempt.
Future<T> retry<T>(
  FutureOr<T> Function() fn, {
  FutureOr<bool> Function(Exception) retryIf,
  int maxAttempts = 5,
  Duration delayDuration = const Duration(seconds: 3),
}) async {
  int attempt = 0;
  while (true) {
    attempt++; // first invocation is the first attempt
    try {
      return await fn();
    } on Exception catch (e) {
      if (attempt >= maxAttempts ||
          (retryIf != null && !(await retryIf(e)))) {
        rethrow;
      }
    }

    // Sleep for a delay
    await Future<void>.delayed(delayDuration);
  }
}