add server.status notification

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 'package:analysis_server/src/analysis_logger.dart';
 import 'package:analysis_server/src/channel.dart';
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_core.dart';
+import 'package:analyzer/src/generated/source.dart';
 
 /**
  * Instances of the class [AnalysisServer] implement a server that listens on a
  * [CommunicationChannel] for analysis requests and process them.
  */
 class AnalysisServer {
   /**
    * The name of the notification of new errors associated with a source.
    */
   static const String ERROR_NOTIFICATION_NAME = 'context.errors';
@@ skipping 12 matching lines @@
    * The name of the parameter whose value is a source.
    */
   static const String SOURCE_PARAM = 'source';
 
   /**
    * The event name of the connected notification.
    */
   static const String CONNECTED_NOTIFICATION = 'server.connected';
 
   /**
+   * The event name of the status notification.
+   */
+  static const String STATUS_NOTIFICATION = 'server.status';
+
+  /**
    * The channel from which requests are received and to which responses should
    * be sent.
    */
   final ServerCommunicationChannel channel;
 
   /**
    * A flag indicating whether the server is running.  When false, contexts
    * will no longer be added to [contextWorkQueue], and [performTask] will
    * discard any tasks it finds on [contextWorkQueue].
    */
   bool running;
 
   /**
    * A list of the request handlers used to handle the requests sent to this
    * server.
    */
   List<RequestHandler> handlers;
 
   /**
    * A table mapping context id's to the analysis contexts associated with them.
    */
   final Map<String, AnalysisContext> contextMap = new Map<String, AnalysisContext>();
 
   /**
    * A table mapping analysis contexts to the context id's associated with them.
    */
   final Map<AnalysisContext, String> contextIdMap = new Map<AnalysisContext, String>();
 
   /**
+   * The context identifier used in the last status notification.
+   */
+  String lastStatusNotificationContextId = null;
+
+  /**
    * A list of the analysis contexts for which analysis work needs to be
    * performed.
    *
    * Invariant: when this list is non-empty, there is exactly one pending call
    * to [performTask] on the event queue.  When this list is empty, there are
    * no calls to [performTask] on the event queue.
    */
   final List<AnalysisContext> contextWorkQueue = new List<AnalysisContext>();
 
   /**
@@ skipping 83 matching lines @@
       return;
     }
     //
     // Look for a context that has work to be done and then perform one task.
     //
     List<ChangeNotice> notices = null;
     String contextId;
     try {
       AnalysisContext context = contextWorkQueue[0];
       contextId = contextIdMap[context];
       AnalysisResult result = context.performAnalysisTask();

[Paul Berry, 2014/05/27 16:09:26]

I think the call to sendStatusNotification(contextId) needs to go here, just
before the call to performAnalysisTask().  That way if the first analysis task
freezes (or takes a long time to execute) the user will get an accurate picture
of what's happening.

[danrubel, 2014/05/28 02:02:00]

Good suggestion. Done.

       notices = result.changeNotices;
     } finally {
       if (notices == null) {
         // Either we have no more work to do for this context, or there was an
         // unhandled exception trying to perform the analysis.  In either case,
         // remove the context form the work queue so we won't try to do more
         // analysis on it.
         contextWorkQueue.removeAt(0);
       }
       //
       // Schedule this method to be run again if there is any more work to be
       // done.
       //
       if (!contextWorkQueue.isEmpty) {
         _scheduleTask();
       }
     }
     if (notices != null) {
+      sendStatusNotification(contextId);
       sendNotices(contextId, notices);
+    } else {
+      sendStatusNotification(null);
     }
   }
 
   /**
    * Send the information in the given list of notices back to the client.
    */
   void sendNotices(String contextId, List<ChangeNotice> notices) {
     for (int i = 0; i < notices.length; i++) {
       ChangeNotice notice = notices[i];
       Notification notification = new Notification(ERROR_NOTIFICATION_NAME);
       notification.setParameter(CONTEXT_ID_PARAM, contextId);
       notification.setParameter(SOURCE_PARAM, notice.source.encoding);
       notification.setParameter(ERRORS_PARAM, notice.errors.map(
           errorToJson).toList());
       sendNotification(notification);
     }
   }
 
+  /**
+   * Send status notification to the client. The `contextId` indicates
+   * the current context being analyzed or `null` if analysis is complete.
+   */
+  void sendStatusNotification(String contextId) {
+    if (contextId == lastStatusNotificationContextId) {
+      return;
+    }
+    lastStatusNotificationContextId = contextId;
+    Notification notification = new Notification(STATUS_NOTIFICATION);
+    Map<String, Object> analysis = new Map();
+    if (contextId != null) {
+      analysis['analyzing'] = true;
+      // TODO(danrubel): replace contextId with real analysisTarget
+      analysis['analysisTarget'] = contextId;
+    } else {
+      analysis['analyzing'] = false;
+    }
+    notification.params['analysis'] = analysis;
+    channel.sendNotification(notification);
+  }
+
   static Map<String, Object> errorToJson(AnalysisError analysisError) {
     // TODO(paulberry): move this function into the AnalysisError class.
 
     // TODO(paulberry): we really shouldn't be exposing errorCode.ordinal
     // outside the analyzer, since the ordinal numbers change whenever we
     // regenerate the analysis engine.
     Map<String, Object> result = {
       'source': analysisError.source.encoding,
       'errorCode': (analysisError.errorCode as Enum).ordinal,
       'offset': analysisError.offset,
@@ skipping 40 matching lines @@
 /**
  * An enumeration of the services provided by the server domain.
  */
 class ServerService extends Enum2<ServerService> {
   static const ServerService STATUS = const ServerService('STATUS', 0);
 
   static const List<ServerService> VALUES = const [STATUS];
 
   const ServerService(String name, int ordinal) : super(name, ordinal);
 }