Initial support for execution domain

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 189 matching lines @@
       new HashMap<AnalysisService, Set<String>>();
 
   /**
    * A table mapping [AnalysisContext]s to the completers that should be
    * completed when analysis of this context is finished.
    */
   Map<AnalysisContext, Completer<AnalysisDoneReason>> contextAnalysisDoneCompleters =
       new HashMap<AnalysisContext, Completer<AnalysisDoneReason>>();
 
   /**
+   * The listeners that are listening for lifecycle events from this server.
+   */
+  List<AnalysisServerListener> listeners = <AnalysisServerListener>[];
+
+  /**
    * True if any exceptions thrown by analysis should be propagated up the call
    * stack.
    */
   bool rethrowExceptions;
 
   /**
    * Initialize a newly created server to receive requests from and send
    * responses to the given [channel].
    *
    * If [rethrowExceptions] is true, then any exceptions thrown by analysis are
@@ skipping 100 matching lines @@
     //
     // Update the defaults used to create new contexts.
     //
     AnalysisOptionsImpl options = contextDirectoryManager.defaultOptions;
     optionUpdaters.forEach((OptionUpdater optionUpdater) {
       optionUpdater(options);
     });
   }
 
   /**
+   * Add the given [listener] to the list of listeners that are listening for
+   * lifecycle events from this server.
+   */
+  void addAnalysisServerListener(AnalysisServerListener listener) {
+    if (!listeners.contains(listener)) {
+      listeners.add(listener);
+    }
+  }
+
+  /**
    * Adds the given [ServerOperation] to the queue, but does not schedule
    * operations execution.
    */
   void addOperation(ServerOperation operation) {
     operationQueue.add(operation);
   }
 
   /**
    * The socket from which requests are being read has been closed.
    */
@@ skipping 61 matching lines @@
   /**
    * Returns `true` if errors should be reported for [file] with the given
    * absolute path.
    */
   bool shouldSendErrorsNotificationFor(String file) {
     // TODO(scheglov) add support for the "--no-error-notification" flag.
     return contextDirectoryManager.isInAnalysisRoot(file);
   }
 
   /**
+   * Return `true` if analysis is complete.
+   */
+  bool isAnalysisComplete() {
+    return operationQueue.isEmpty;
+  }
+
+  /**
    * Returns `true` if the given [AnalysisContext] is a priority one.
    */
   bool isPriorityContext(AnalysisContext context) {
     // TODO(scheglov) implement support for priority sources/contexts
     return false;
   }
 
   /**
    * Perform the next available [ServerOperation].
    */
@@ skipping 18 matching lines @@
             'Unexpected exception during analysis',
             new CaughtException(exception, stackTrace));
       }
       _sendServerErrorNotification(exception, stackTrace);
       shutdown();
     } finally {
       if (!operationQueue.isEmpty) {
         _schedulePerformOperation();
       } else {
         sendStatusNotification(null);
+        _notifyAnalysisComplete();
       }
     }
   }
 
   /**
+   * Remove the given [listener] from the list of listeners that are listening
+   * for lifecycle events from this server.
+   */
+  void removeAnalysisServerListener(AnalysisServerListener listener) {
+    listeners.remove(listener);
+  }
+
+  /**
    * Send status notification to the client. The `operation` is the operation
    * being performed or `null` if analysis is complete.
    */
   void sendStatusNotification(ServerOperation operation) {
     // Only send status when subscribed.
     if (!serverServices.contains(ServerService.STATUS)) {
       return;
     }
     // Only send status when it changes
     bool isAnalyzing = operation != null;
@@ skipping 111 matching lines @@
             }
           }
         }
       }
     });
     // remember new subscriptions
     this.analysisServices = subscriptions;
   }
 
   /**
+   * Return the [AnalysisContext]s that are being used to analyze the analysis
+   * roots.
+   */
+  Iterable<AnalysisContext> getAnalysisContexts() {
+    return folderMap.values;
+  }
+
+  /**
    * Return the [AnalysisContext] that is used to analyze the given [path].
    * Return `null` if there is no such context.
    */
   AnalysisContext getAnalysisContext(String path) {
     // try to find a containing context
     for (Folder folder in folderMap.keys) {
       if (path.startsWith(folder.path)) {
         return folderMap[folder];
       }
     }
     // check if there is a context that analyzed this source
-    {
-      Source source = getSource(path);
-      for (AnalysisContext context in folderMap.values) {
-        SourceKind kind = context.getKindOf(source);
-        if (kind != null) {
-          return context;
-        }
+    Source source = getSource(path);
+    for (AnalysisContext context in folderMap.values) {
+      SourceKind kind = context.getKindOf(source);
+      if (kind != null) {
+        return context;
       }
     }
     return null;
   }
 
   /**
    * Return the [Source] of the Dart file with the given [path].
    */
   Source getSource(String path) {
     // try SDK
@@ skipping 212 matching lines @@
   }
 
   /**
    * Return `true` if all operations have been performed in this [AnalysisServer].
    */
   bool test_areOperationsFinished() {
     return operationQueue.isEmpty;
   }
 
   /**
+   * Notify all listeners that analysis is complete.
+   */
+  void _notifyAnalysisComplete() {
+    listeners.forEach((AnalysisServerListener listener) {
+      listener.analysisComplete();
+    });
+  }
+
+  /**
    * Schedules [performOperation] exection.
    */
   void _schedulePerformOperation() {
     new Future(performOperation);
   }
 
   /**
    * Sends a fatal `server.error` notification.
    */
   void _sendServerErrorNotification(exception, stackTrace) {
@@ skipping 10 matching lines @@
       stackTraceString = stackTrace.toString();
     } else {
       stackTraceString = 'null stackTrace';
     }
     // send the notification
     channel.sendNotification(new ServerErrorParams(true, exceptionString,
         stackTraceString).toNotification());
   }
 }
 
+/**
+ * An object that is listening for lifecycle events from an analysis server.
+ */
+abstract class AnalysisServerListener {
+  /**
+   * Analysis is complete.
+   */
+  void analysisComplete();
+}
 
 typedef void OptionUpdater(AnalysisOptionsImpl options);