Make "server.shutdown" exit the analysis server.

pkg/analysis_server/test/integration/integration_tests.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library test.integration.analysis;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
 
 import 'package:analysis_server/src/constants.dart';
 import 'package:path/path.dart';
 import 'package:unittest/unittest.dart';
 
 /**
  * Base class for analysis server integration tests.
  */
 abstract class AbstractAnalysisServerIntegrationTest {
   /**
+   * Amount of time to give the server to respond to a shutdown request before
+   * forcibly terminating it.
+   */
+  static const Duration SHUTDOWN_TIMEOUT = const Duration(seconds: 5);
+
+  /**
    * Connection to the analysis server.
    */
   Server server;
 
   /**
    * Temporary directory in which source files can be stored.
    */
   Directory sourceDirectory;
 
   /**
    * Map from file path to the list of analysis errors which have most recently
    * been received for the file.
    */
   HashMap<String, dynamic> currentAnalysisErrors = new HashMap<String, dynamic>(
       );
 
   /**
+   * True if the teardown process should skip sending a "server.shutdown"
+   * request (e.g. because the server is known to have already shutdown).
+   */
+  bool skipShutdown = false;
+
+  /**
    * Write a source file with the given contents.  [relativePath]
    * is relative to [sourceDirectory]; on Windows any forward slashes it
    * contains are converted to backslashes.
    *
    * If the file didn't previously exist, it is created.  If it did, it is
    * overwritten.
    */
   void writeFile(String relativePath, String contents) {
     String absolutePath = normalizePath(relativePath);
     new Directory(dirname(absolutePath)).createSync(recursive: true);
@@ skipping 71 matching lines @@
    */
   Future setUp() {
     sourceDirectory = Directory.systemTemp.createTempSync('analysisServer');
     return Server.start().then((Server server) {
       this.server = server;
       server.onNotification(ANALYSIS_ERRORS).listen((params) {
         expect(params, isMap);
         expect(params['file'], isString);
         currentAnalysisErrors[params['file']] = params['errors'];
       });
+      server.exitCode.then((_) { skipShutdown = true; });
     });
   }
 
   /**
-   * After every test, the server stopped and [sourceDirectory] is deleted.
+   * After every test, the server is stopped and [sourceDirectory] is deleted.
    */
   Future tearDown() {
-    return server.kill().then((_) {
+    return _shutdownIfNeeded().then((_) {
       sourceDirectory.deleteSync(recursive: true);
     });
   }
+
+  /**
+   * If [skipShutdown] is not set, shut down the server.
+   */
+  Future _shutdownIfNeeded() {
+    if (skipShutdown) {
+      return new Future.value();
+    }
+    // Give the server a short time to comply with the shutdown request; if it
+    // doesn't exit, then forcibly terminate it.
+    Completer processExited = new Completer();
+    server.send(SERVER_SHUTDOWN, null);
+    server.exitCode.whenComplete(() {
+      processExited.complete();
+    });
+    new Future.delayed(SHUTDOWN_TIMEOUT).then((_) {
+      if (!processExited.isCompleted) {
+        server.kill();
+      }
+    });
+    return processExited.future;
+  }
 }
 
 // Matchers for data types defined in the analysis server API
 // ==========================================================
 // TODO(paulberry): add more matchers.
 
 // Matchers common to all domains
 // ------------------------------
 
 const Matcher isResponse = const MatchesJsonObject('response', const {
@@ skipping 421 matching lines @@
           // event of an error.
           expect(message, isNotification);
         }
       });
       process.stderr.transform((new Utf8Codec()).decoder).transform(
           new LineSplitter()).listen((String line) {
         String trimmedLine = line.trim();
         server._recordStdio('ERR:  $trimmedLine');
         server._badDataFromServer();
       });
+      process.exitCode.then((int code) {
+        server._recordStdio('TERMINATED WITH EXIT CODE $code');
+        if (code != 0) {
+          server._badDataFromServer();
+        }
+      });
       return server;
     });
   }
 
   /**
+   * Future that completes when the server process exits.
+   */
+  Future<int> get exitCode => _process.exitCode;
+
+  /**
    * Stop the server.
    */
   Future kill() {
+    debugStdio();
+    _recordStdio('PROCESS FORCIBLY TERMINATED');
     _process.kill();
     return _process.exitCode;
   }
 
   /**
    * Send a command to the server.  An 'id' will be automatically assigned.
    * The returned [Future] will be completed when the server acknowledges the
    * command with a response.  If the server acknowledges the command with a
    * normal (non-error) response, the future will be completed with the 'result'
    * field from the response.  If the server acknowledges the command with an
@@ skipping 54 matching lines @@
    * Record a message that was exchanged with the server, and print it out if
    * [debugStdio] has been called.
    */
   void _recordStdio(String line) {
     if (_debuggingStdio) {
       print(line);
     }
     _recordedStdio.add(line);
   }
 }