Avoid analysis server crash when reanalyze invoked during analysis.

pkg/analysis_server/lib/src/analysis_server.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 analysis.server;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/file_system/file_system.dart';
@@ skipping 161 matching lines @@
    */
   final DartSdk defaultSdk;
 
   /**
    * A table mapping [Folder]s to the [AnalysisContext]s associated with them.
    */
   final Map<Folder, AnalysisContext> folderMap =
       new HashMap<Folder, AnalysisContext>();
 
   /**
+   * True if a call to [performOperation] is currently executing, or there is a
+   * pending future which will execute [performOperation].
+   */
+  bool operationLoopRunning = false;
+
+  /**
    * A queue of the operations to perform in this server.
-   *
-   * Invariant: when this queue is non-empty, there is exactly one pending call
-   * to [performOperation] on the event queue.  When this list is empty, there are
-   * no calls to [performOperation] on the event queue.
    */
   ServerOperationQueue operationQueue;
 
   /**
    * A set of the [ServerService]s to send notifications for.
    */
   Set<ServerService> serverServices = new HashSet<ServerService>();
 
   /**
    * A table mapping [AnalysisService]s to the file paths for which these
@@ skipping 64 matching lines @@
   void fileAnalyzed(ChangeNotice notice) {
     if (contextDirectoryManager.isInAnalysisRoot(notice.source.fullName)) {
       _onFileAnalyzedController.add(notice);
     }
   }
 
   /**
    * Schedules execution of the given [ServerOperation].
    */
   void scheduleOperation(ServerOperation operation) {
-    bool wasEmpty = operationQueue.isEmpty;
     addOperation(operation);
-    if (wasEmpty) {
+    if (!operationLoopRunning) {
       _schedulePerformOperation();
+      operationLoopRunning = true;
     }
   }
 
   /**
    * Schedules analysis of the given context.
    */
   void schedulePerformAnalysisOperation(AnalysisContext context) {
     _onAnalysisStartedController.add(context);
     scheduleOperation(new PerformAnalysisOperation(context, false));
   }
@@ skipping 193 matching lines @@
    */
   bool isPriorityContext(AnalysisContext context) {
     // TODO(scheglov) implement support for priority sources/contexts
     return false;
   }
 
   /**
    * Perform the next available [ServerOperation].
    */
   void performOperation() {
+    assert(operationLoopRunning);
     if (!running) {
       // An error has occurred, or the connection to the client has been
       // closed, since this method was scheduled on the event queue.  So
       // don't do anything.  Instead clear the operation queue.
       operationQueue.clear();
+      operationLoopRunning = false;
       return;
     }
     // prepare next operation
     ServerOperation operation = operationQueue.take();
+    if (operation == null) {
+      // This can happen if the operation queue is cleared while the operation
+      // loop is in progress.  No problem; we just need to exit the operation
+      // loop and wait for the next operation to be added.
+      operationLoopRunning = false;
+      return;
+    }
     sendStatusNotification(operation);
     // perform the operation
     try {
       operation.perform(this);
     } catch (exception, stackTrace) {
       AnalysisEngine.instance.logger.logError("${exception}\n${stackTrace}");
       if (rethrowExceptions) {
         throw new AnalysisException(
             'Unexpected exception during analysis',
             new CaughtException(exception, stackTrace));
       }
       _sendServerErrorNotification(exception, stackTrace);
       shutdown();
     } finally {
       if (!operationQueue.isEmpty) {
         _schedulePerformOperation();
       } else {
         sendStatusNotification(null);
         _onAnalysisCompleteController.add(null);
+        operationLoopRunning = false;

[Brian Wilkerson, 2014/10/28 20:37:14]

If an exception occurs in sendStatusNotification, won't this make it impossible
for the server to ever perform another operation?

I think it's safer to change the flag to mean that "there is a pending future
which will execute [performOperation]".

       }
     }
   }
 
   /**
    * Trigger reanalysis of all files from disk.
    */
   void reanalyze() {
     // Clear any operations that are pending.
     operationQueue.clear();
@@ skipping 409 matching lines @@
     // send the notification
     channel.sendNotification(
         new ServerErrorParams(
             true,
             exceptionString,
             stackTraceString).toNotification());
   }
 }
 
 typedef void OptionUpdater(AnalysisOptionsImpl options);