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].
    */
@@ skipping 19 matching lines @@
    * 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>();
 
   /**
+   * The time at which a status message was sent to the client.
+   */
+  final Stopwatch statusStopwatch = new Stopwatch();
+
+  /**
    * Initialize a newly created server to receive requests from and send
    * responses to the given [channel].
    */
   AnalysisServer(this.channel) {
     AnalysisEngine.instance.logger = new AnalysisLogger();
     running = true;
     Notification notification = new Notification(CONNECTED_NOTIFICATION);
     channel.sendNotification(notification);
     channel.listen(handleRequest, onDone: done, onError: error);
   }
@@ skipping 65 matching lines @@
     }
     if (contextWorkQueue.isEmpty) {
       // Nothing to do.
       return;
     }
     //
     // Look for a context that has work to be done and then perform one task.
     //
     List<ChangeNotice> notices = null;
     String contextId;
+    AnalysisResult result;
     try {
       AnalysisContext context = contextWorkQueue[0];
       contextId = contextIdMap[context];
-      AnalysisResult result = context.performAnalysisTask();
+      result = context.performAnalysisTask();
       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();
       }
     }
+    sendStatusNotification(result);
     if (notices != null) {
       sendNotices(contextId, notices);
     }
   }
 
   /**
    * 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.
+   */
+  void sendStatusNotification(AnalysisResult result) {
+    Notification notification = new Notification(STATUS_NOTIFICATION);
+    if (result.changeNotices != null) {
+      // Throttle status messages to at most 1 every half second
+      if (!statusStopwatch.isRunning) {
+        statusStopwatch.start();
+      } else if (statusStopwatch.elapsedMilliseconds > 500) {
+        statusStopwatch.reset();
+      } else {
+        return;

[Paul Berry, 2014/05/23 15:56:45]

This technique for throttling status notifications breaks what is IMO one of the
primary use case for having status notifications in the first place: to report
the current state of analysis to the user so that if analysis is slow or hangs,
they know what it is currently trying to do.  As written, we drop any status
notifications that occur within 500ms of the previously reported status.  That's
fine if all analysis is quick, but if we analyze file A in 100ms, and then
analyzing file B takes 30s, the status seen by the user will indicate that we're
analyzing file A that entire time.

That could lead to some really confusing bug reports if a user ever encounters a
case where analysis hangs.

Unfortunately due to the single-threaded nature of dart, this isn't going to be
trivial to fix--we probably have to create a new isolate.  Alternatively, we
could hold off on throttling until we have enough of an implementation working
that we can measure performance and confirm that it's really needed.

+      }
+      String shortMessage = 'Analyzing';
+      String longMessage = 'Analyzing';
+      if (result.changeNotices.length > 0) {
+        ChangeNotice notice = result.changeNotices[0];
+        if (notice != null) {
+          shortMessage = 'Analyzing ${notice.source.shortName}';

[Paul Berry, 2014/05/23 15:56:45]

Similar concern here.  As you've arranged things, sendStatusNotification() won't
be called until analysis for the given file has completed.  So any time we say
"analyzing foo" we have actually already finished analyzing foo and moved on to
analyze some other file.  Again, not a problem if analysis is quick, but if a
bug makes analysis slow for a certain file, the status messages aren't going to
properly reflect which file is the slow one.

+          longMessage = 'Analyzing ${notice.source.fullName}';
+        }
+      }
+      // TODO(danrubel): improve message once AnalysisResult can provide
+      // something more human readable
+      notification.params['shortMessage'] = shortMessage;
+      notification.params['longMessage'] = longMessage;
+      notification.params['isAnalyzing'] = true;
+    } else {
+      // Reset to ensure notification when analysis starts again
+      statusStopwatch..stop()..reset();
+      notification.params['shortMessage'] = 'Analysis complete';
+      notification.params['longMessage'] = 'Analysis complete';
+      notification.params['isAnalyzing'] = false;
+    }
+    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 12 matching lines @@
   void sendNotification(Notification notification) {
     channel.sendNotification(notification);
   }
 
   void _scheduleTask() {
     new Future(performTask).catchError((ex, st) {
       AnalysisEngine.instance.logger.logError("${ex}\n${st}");
     });
   }
 }