fix(dart_frog_cli): kill dev server child process on windows (#64)

Author: felangel

packages/dart_frog_cli/lib/src/commands/create/create.dart

@@ -41,7 +41,7 @@ class CreateCommand extends DartFrogCommand {
     final outputDirectory = _outputDirectory;
     final projectName = _projectName;
     final generator = await _generator(createDartFrogBundle);
-    final generateDone = logger.progress('Creating $projectName');
+    final generateProgress = logger.progress('Creating $projectName');
     final vars = <String, dynamic>{
       'name': projectName,
       'output_directory': outputDirectory.absolute.path
@@ -51,7 +51,7 @@ class CreateCommand extends DartFrogCommand {
       DirectoryGeneratorTarget(outputDirectory),
       vars: vars,
     );
-    generateDone();
+    generateProgress.complete();
 
     await generator.hooks.postGen(vars: vars, workingDirectory: cwd.path);
 

packages/dart_frog_cli/lib/src/commands/dev/dev.dart

@@ -1,5 +1,5 @@
 import 'dart:convert';
-import 'dart:io';
+import 'dart:io' as io;
 
 import 'package:dart_frog_cli/src/command.dart';
 import 'package:dart_frog_cli/src/commands/commands.dart';
@@ -8,18 +8,27 @@ import 'package:mason/mason.dart';
 import 'package:path/path.dart' as path;
 import 'package:watcher/watcher.dart';
 
-/// Typedef for [Process.start].
-typedef ProcessStart = Future<Process> Function(
+/// Typedef for [io.Process.start].
+typedef ProcessStart = Future<io.Process> Function(
   String executable,
   List<String> arguments, {
   bool runInShell,
 });
 
+/// Typedef for [io.Process.run].
+typedef ProcessRun = Future<io.ProcessResult> Function(
+  String executable,
+  List<String> arguments,
+);
+
 /// Typedef for [DirectoryWatcher.new].
 typedef DirectoryWatcherBuilder = DirectoryWatcher Function(
   String directory,
 );
 
+/// Typedef for [io.exit].
+typedef Exit = dynamic Function(int exitCode);
+
 /// {@template dev_command}
 /// `dart_frog dev` command which starts the dev server`.
 /// {@endtemplate}
@@ -29,14 +38,26 @@ class DevCommand extends DartFrogCommand {
     super.logger,
     DirectoryWatcherBuilder? directoryWatcher,
     GeneratorBuilder? generator,
+    Exit? exit,
+    bool? isWindows,
+    ProcessRun? runProcess,
+    io.ProcessSignal? sigint,
     ProcessStart? startProcess,
   })  : _directoryWatcher = directoryWatcher ?? DirectoryWatcher.new,
         _generator = generator ?? MasonGenerator.fromBundle,
-        _startProcess = startProcess ?? Process.start;
+        _exit = exit ?? io.exit,
+        _isWindows = isWindows ?? io.Platform.isWindows,
+        _runProcess = runProcess ?? io.Process.run,
+        _sigint = sigint ?? io.ProcessSignal.sigint,
+        _startProcess = startProcess ?? io.Process.start;
 
+  final DirectoryWatcherBuilder _directoryWatcher;
   final GeneratorBuilder _generator;
+  final Exit _exit;
+  final bool _isWindows;
+  final ProcessRun _runProcess;
+  final io.ProcessSignal _sigint;
   final ProcessStart _startProcess;
-  final DirectoryWatcherBuilder _directoryWatcher;
 
   @override
   final String description = 'Run a local development server.';
@@ -56,7 +77,9 @@ class DevCommand extends DartFrogCommand {
       );
 
       final _ = await generator.generate(
-        DirectoryGeneratorTarget(Directory(path.join(cwd.path, '.dart_frog'))),
+        DirectoryGeneratorTarget(
+          io.Directory(path.join(cwd.path, '.dart_frog')),
+        ),
         vars: vars,
         fileConflictResolution: FileConflictResolution.overwrite,
       );
@@ -69,18 +92,31 @@ class DevCommand extends DartFrogCommand {
         runInShell: true,
       );
 
+      // On Windows listen for CTRL-C and use taskkill to kill
+      // the spawned process along with any child processes.
+      // https://github.com/dart-lang/sdk/issues/22470
+      if (_isWindows) {
+        _sigint.watch().listen((_) async {
+          final result = await _runProcess(
+            'taskkill',
+            ['/F', '/T', '/PID', '${process.pid}'],
+          );
+          _exit(result.exitCode);
+        });
+      }
+
       process.stdout.listen((_) => logger.info(utf8.decode(_)));
       process.stderr.listen((_) => logger.err(utf8.decode(_)));
     }
 
-    final done = logger.progress('Serving');
+    final progress = logger.progress('Serving');
     await codegen();
     await serve();
-    done('Running on http://localhost:8080');
+    progress.complete('Running on http://localhost:8080');
 
     final watcher = _directoryWatcher(path.join(cwd.path, 'routes'));
     final subscription = watcher.events.listen((event) async {
-      final file = File(event.path);
+      final file = io.File(event.path);
       if (file.existsSync()) {
         final contents = await file.readAsString();
         if (contents.isNotEmpty) {

packages/dart_frog_cli/test/src/commands/build/build_test.dart

@@ -9,6 +9,8 @@ class _MockMasonGenerator extends Mock implements MasonGenerator {}
 
 class _MockGeneratorHooks extends Mock implements GeneratorHooks {}
 
+class _MockProgress extends Mock implements Progress {}
+
 class _FakeDirectoryGeneratorTarget extends Fake
     implements DirectoryGeneratorTarget {}
 
@@ -19,12 +21,14 @@ void main() {
     });
 
     late Logger logger;
+    late Progress progress;
     late MasonGenerator generator;
     late BuildCommand command;
 
     setUp(() {
       logger = _MockLogger();
-      when(() => logger.progress(any())).thenReturn(([_]) {});
+      progress = _MockProgress();
+      when(() => logger.progress(any())).thenReturn(progress);
       generator = _MockMasonGenerator();
       command = BuildCommand(
         logger: logger,

packages/dart_frog_cli/test/src/commands/create/create_test.dart

@@ -11,6 +11,8 @@ class _MockArgResults extends Mock implements ArgResults {}
 
 class _MockLogger extends Mock implements Logger {}
 
+class _MockProgress extends Mock implements Progress {}
+
 class _MockMasonGenerator extends Mock implements MasonGenerator {}
 
 class _MockGeneratorHooks extends Mock implements GeneratorHooks {}
@@ -26,13 +28,15 @@ void main() {
 
     late ArgResults argResults;
     late Logger logger;
+    late Progress progress;
     late MasonGenerator generator;
     late CreateCommand command;
 
     setUp(() {
       argResults = _MockArgResults();
       logger = _MockLogger();
-      when(() => logger.progress(any())).thenReturn(([_]) {});
+      progress = _MockProgress();
+      when(() => logger.progress(any())).thenReturn(progress);
       generator = _MockMasonGenerator();
       command = CreateCommand(
         logger: logger,

packages/dart_frog_cli/test/src/commands/dev/dev_test.dart

@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'dart:io';
 
 import 'package:dart_frog_cli/src/commands/commands.dart';
@@ -16,6 +17,12 @@ class _MockGeneratorHooks extends Mock implements GeneratorHooks {}
 
 class _MockProcess extends Mock implements Process {}
 
+class _MockProcessResult extends Mock implements ProcessResult {}
+
+class _MockProcessSignal extends Mock implements ProcessSignal {}
+
+class _MockProgress extends Mock implements Progress {}
+
 class _FakeDirectoryGeneratorTarget extends Fake
     implements DirectoryGeneratorTarget {}
 
@@ -26,28 +33,41 @@ void main() {
     });
 
     late DirectoryWatcher directoryWatcher;
+    late MasonGenerator generator;
+    late bool isWindows;
+    late Progress progress;
     late Logger logger;
     late Process process;
-    late MasonGenerator generator;
+    late ProcessResult processResult;
+    late ProcessSignal sigint;
     late DevCommand command;
 
     setUp(() {
       directoryWatcher = _MockDirectoryWatcher();
+      generator = _MockMasonGenerator();
+      isWindows = false;
       logger = _MockLogger();
-      when(() => logger.progress(any())).thenReturn(([_]) {});
+      progress = _MockProgress();
+      when(() => logger.progress(any())).thenReturn(progress);
       process = _MockProcess();
-      generator = _MockMasonGenerator();
+      processResult = _MockProcessResult();
+      sigint = _MockProcessSignal();
       command = DevCommand(
         logger: logger,
         directoryWatcher: (_) => directoryWatcher,
         generator: (_) async => generator,
+        isWindows: isWindows,
+        runProcess: (String executable, List<String> arguments) async {
+          return processResult;
+        },
         startProcess: (
           String executable,
           List<String> arguments, {
           bool runInShell = false,
         }) async {
           return process;
         },
+        sigint: sigint,
       );
     });
 
@@ -83,5 +103,68 @@ void main() {
       final exitCode = await command.run();
       expect(exitCode, equals(ExitCode.success.code));
     });
+
+    test('kills all child processes when sigint received on windows', () async {
+      const processId = 42;
+      final generatorHooks = _MockGeneratorHooks();
+      final processRunCalls = <List<String>>[];
+      int? exitCode;
+      when(
+        () => generatorHooks.preGen(
+          vars: any(named: 'vars'),
+          workingDirectory: any(named: 'workingDirectory'),
+          onVarsChanged: any(named: 'onVarsChanged'),
+        ),
+      ).thenAnswer((invocation) async {
+        (invocation.namedArguments[const Symbol('onVarsChanged')] as Function(
+          Map<String, dynamic> vars,
+        ))
+            .call(<String, dynamic>{});
+      });
+      when(
+        () => generator.generate(
+          any(),
+          vars: any(named: 'vars'),
+          fileConflictResolution: FileConflictResolution.overwrite,
+        ),
+      ).thenAnswer((_) async => []);
+      when(() => generator.hooks).thenReturn(generatorHooks);
+      when(() => process.stdout).thenAnswer((_) => const Stream.empty());
+      when(() => process.stderr).thenAnswer((_) => const Stream.empty());
+      when(() => process.pid).thenReturn(processId);
+      when(() => processResult.exitCode).thenReturn(ExitCode.success.code);
+      when(
+        () => directoryWatcher.events,
+      ).thenAnswer((_) => StreamController<WatchEvent>().stream);
+      when(() => sigint.watch()).thenAnswer((_) => Stream.value(sigint));
+      command = DevCommand(
+        logger: logger,
+        directoryWatcher: (_) => directoryWatcher,
+        generator: (_) async => generator,
+        exit: (code) => exitCode = code,
+        isWindows: true,
+        runProcess: (String executable, List<String> arguments) async {
+          processRunCalls.add([executable, ...arguments]);
+          return processResult;
+        },
+        startProcess: (
+          String executable,
+          List<String> arguments, {
+          bool runInShell = false,
+        }) async {
+          return process;
+        },
+        sigint: sigint,
+      );
+      command.run().ignore();
+      await untilCalled(() => process.pid);
+      expect(exitCode, equals(ExitCode.success.code));
+      expect(
+        processRunCalls,
+        equals([
+          ['taskkill', '/F', '/T', '/PID', '$processId']
+        ]),
+      );
+    });
   });
 }