framework.dart 8.37 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 8 9 10
// 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:developer';
import 'dart:io';
import 'dart:isolate';

11
import 'package:path/path.dart' as path;
12
import 'package:logging/logging.dart';
13
import 'package:stack_trace/stack_trace.dart';
14

15
import 'adb.dart';
16
import 'running_processes.dart';
17
import 'task_result.dart';
18 19
import 'utils.dart';

20 21 22 23 24 25 26 27 28 29
/// Identifiers for devices that should never be rebooted.
final Set<String> noRebootForbidList = <String>{
  '822ef7958bba573829d85eef4df6cbdd86593730', // 32bit iPhone requires manual intervention on reboot.
};

/// The maximum number of test runs before a device must be rebooted.
///
/// This number was chosen arbitrarily.
const int maxiumRuns = 30;

30 31
/// Represents a unit of work performed in the CI environment that can
/// succeed, fail and be retried independently of others.
32
typedef TaskFunction = Future<TaskResult> Function();
33 34 35 36 37

bool _isTaskRegistered = false;

/// Registers a [task] to run, returns the result when it is complete.
///
38
/// The task does not run immediately but waits for the request via the
39 40
/// VM service protocol to run it.
///
41
/// It is OK for a [task] to perform many things. However, only one task can be
42
/// registered per Dart VM.
43
Future<TaskResult> task(TaskFunction task) async {
44
  if (_isTaskRegistered)
45
    throw StateError('A task is already registered');
46 47 48

  _isTaskRegistered = true;

49
  // TODO(ianh): allow overriding logging.
50 51 52 53 54
  Logger.root.level = Level.ALL;
  Logger.root.onRecord.listen((LogRecord rec) {
    print('${rec.level.name}: ${rec.time}: ${rec.message}');
  });

55
  final _TaskRunner runner = _TaskRunner(task);
56 57 58 59 60 61 62 63
  runner.keepVmAliveUntilTaskRunRequested();
  return runner.whenDone;
}

class _TaskRunner {
  _TaskRunner(this.task) {
    registerExtension('ext.cocoonRunTask',
        (String method, Map<String, String> parameters) async {
64
      final Duration taskTimeout = parameters.containsKey('timeoutInMinutes')
65
        ? Duration(minutes: int.parse(parameters['timeoutInMinutes']))
66
        : null;
67
      final TaskResult result = await run(taskTimeout);
68
      return ServiceExtensionResponse.result(json.encode(result.toJson()));
69 70 71
    });
    registerExtension('ext.cocoonRunnerReady',
        (String method, Map<String, String> parameters) async {
72
      return ServiceExtensionResponse.result('"ready"');
73 74 75
    });
  }

76 77 78 79 80 81 82 83 84 85 86
  final TaskFunction task;

  // TODO(ianh): workaround for https://github.com/dart-lang/sdk/issues/23797
  RawReceivePort _keepAlivePort;
  Timer _startTaskTimeout;
  bool _taskStarted = false;

  final Completer<TaskResult> _completer = Completer<TaskResult>();

  static final Logger logger = Logger('TaskRunner');

87 88 89
  /// Signals that this task runner finished running the task.
  Future<TaskResult> get whenDone => _completer.future;

90
  Future<TaskResult> run(Duration taskTimeout) async {
91 92
    try {
      _taskStarted = true;
93
      print('Running task with a timeout of $taskTimeout.');
94 95 96 97 98 99 100 101 102 103 104 105
      final String exe = Platform.isWindows ? '.exe' : '';
      section('Checking running Dart$exe processes');
      final Set<RunningProcessInfo> beforeRunningDartInstances = await getRunningProcesses(
        processName: 'dart$exe',
      ).toSet();
      final Set<RunningProcessInfo> allProcesses = await getRunningProcesses().toSet();
      beforeRunningDartInstances.forEach(print);
      for (final RunningProcessInfo info in allProcesses) {
        if (info.commandLine.contains('iproxy')) {
          print('[LEAK]: ${info.commandLine} ${info.creationDate} ${info.pid} ');
        }
      }
106 107 108
      print('enabling configs for macOS, Linux, Windows, and Web...');
      final int configResult = await exec(path.join(flutterDirectory.path, 'bin', 'flutter'), <String>[
        'config',
109
        '-v',
110 111 112 113
        '--enable-macos-desktop',
        '--enable-windows-desktop',
        '--enable-linux-desktop',
        '--enable-web'
114
      ], canFail: true);
115 116 117 118
      if (configResult != 0) {
        print('Failed to enable configuration, tasks may not run.');
      }

119 120 121
      Future<TaskResult> futureResult = _performTask();
      if (taskTimeout != null)
        futureResult = futureResult.timeout(taskTimeout);
122

123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
      TaskResult result = await futureResult;

      section('Checking running Dart$exe processes after task...');
      final List<RunningProcessInfo> afterRunningDartInstances = await getRunningProcesses(
        processName: 'dart$exe',
      ).toList();
      for (final RunningProcessInfo info in afterRunningDartInstances) {
        if (!beforeRunningDartInstances.contains(info)) {
          print('$info was leaked by this test.');
          if (result is TaskResultCheckProcesses) {
            result = TaskResult.failure('This test leaked dart processes');
          }
          final bool killed = await killProcess(info.pid);
          if (!killed) {
            print('Failed to kill process ${info.pid}.');
          } else {
            print('Killed process id ${info.pid}.');
          }
        }
      }
143 144
      _completer.complete(result);
      return result;
145
    } on TimeoutException catch (err, stackTrace) {
146
      print('Task timed out in framework.dart after $taskTimeout.');
147 148
      print(err);
      print(stackTrace);
149
      return TaskResult.failure('Task timed out after $taskTimeout');
150
    } finally {
151
      await checkForRebootRequired();
152
      await forceQuitRunningProcesses();
153 154 155 156
      _closeKeepAlivePort();
    }
  }

157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
  Future<void> checkForRebootRequired() async {
    print('Checking for reboot');
    try {
      final Device device = await devices.workingDevice;
      if (noRebootForbidList.contains(device.deviceId)) {
        return;
      }
      final File rebootFile = _rebootFile();
      int runCount;
      if (rebootFile.existsSync()) {
        runCount = int.tryParse(rebootFile.readAsStringSync().trim());
      } else {
        runCount = 0;
      }
      if (runCount < maxiumRuns) {
        rebootFile
          ..createSync()
          ..writeAsStringSync((runCount + 1).toString());
        return;
      }
      rebootFile.deleteSync();
      print('rebooting');
      await device.reboot();
    } on TimeoutException {
      // Could not find device in order to reboot.
    } on DeviceException {
      // No attached device needed to reboot.
    }
  }

187 188 189 190
  /// Causes the Dart VM to stay alive until a request to run the task is
  /// received via the VM service protocol.
  void keepVmAliveUntilTaskRunRequested() {
    if (_taskStarted)
191
      throw StateError('Task already started.');
192 193 194

    // Merely creating this port object will cause the VM to stay alive and keep
    // the VM service server running until the port is disposed of.
195
    _keepAlivePort = RawReceivePort();
196 197

    // Timeout if nothing bothers to connect and ask us to run the task.
198
    const Duration taskStartTimeout = Duration(seconds: 60);
199
    _startTaskTimeout = Timer(taskStartTimeout, () {
200 201 202 203 204 205 206 207
      if (!_taskStarted) {
        logger.severe('Task did not start in $taskStartTimeout.');
        _closeKeepAlivePort();
        exitCode = 1;
      }
    });
  }

208
  /// Disables the keepalive port, allowing the VM to exit.
209 210 211 212 213
  void _closeKeepAlivePort() {
    _startTaskTimeout?.cancel();
    _keepAlivePort?.close();
  }

214
  Future<TaskResult> _performTask() {
215
    final Completer<TaskResult> completer = Completer<TaskResult>();
216 217 218
    Chain.capture(() async {
      completer.complete(await task());
    }, onError: (dynamic taskError, Chain taskErrorStack) {
219
      final String message = 'Task failed: $taskError';
220 221 222 223 224 225 226 227 228
      stderr
        ..writeln(message)
        ..writeln('\nStack trace:')
        ..writeln(taskErrorStack.terse);
      // IMPORTANT: We're completing the future _successfully_ but with a value
      // that indicates a task failure. This is intentional. At this point we
      // are catching errors coming from arbitrary (and untrustworthy) task
      // code. Our goal is to convert the failure into a readable message.
      // Propagating it further is not useful.
229
      if (!completer.isCompleted)
230
        completer.complete(TaskResult.failure(message));
231 232
    });
    return completer.future;
233 234
  }
}
235 236 237 238 239 240 241 242 243 244

File _rebootFile() {
  if (Platform.isLinux || Platform.isMacOS) {
    return File(path.join(Platform.environment['HOME'], '.reboot-count'));
  }
  if (!Platform.isWindows) {
    throw StateError('Unexpected platform ${Platform.operatingSystem}');
  }
  return File(path.join(Platform.environment['USERPROFILE'], '.reboot-count'));
}