Add support for watch events and error notifications

pkg/analysis_server/lib/src/plugin/plugin_manager.dart

 // Copyright (c) 2017, 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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:io' show Platform;
 
 import 'package:analysis_server/src/plugin/notification_manager.dart';
 import 'package:analyzer/context/context_root.dart' as analyzer;
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/src/generated/bazel.dart';
 import 'package:analyzer/src/generated/gn.dart';
+import 'package:analyzer/src/util/glob.dart';
 import 'package:analyzer_plugin/channel/channel.dart';
 import 'package:analyzer_plugin/protocol/protocol.dart';
+import 'package:analyzer_plugin/protocol/protocol_constants.dart';
 import 'package:analyzer_plugin/protocol/protocol_generated.dart';
 import 'package:analyzer_plugin/src/channel/isolate_channel.dart';
 import 'package:analyzer_plugin/src/protocol/protocol_internal.dart';
 import 'package:convert/convert.dart';
 import 'package:crypto/crypto.dart';
 import 'package:meta/meta.dart';
 import 'package:path/path.dart' as path;
+import 'package:watcher/watcher.dart' as watcher;
 
 /**
  * Information about a single plugin.
  */
 class PluginInfo {
   /**
    * The path to the root directory of the definition of the plugin on disk (the
    * directory containing the 'pubspec.yaml' file and the 'bin' directory).
    */
   final String path;
@@ skipping 207 matching lines @@
       }
     }
   }
 
   /**
    * Broadcast a request built from the given [params] to all of the plugins
    * that are currently associated with the given [contextRoot]. Return a list
    * containing futures that will complete when each of the plugins have sent a
    * response.
    */
-  Map<PluginInfo, Future<Response>> broadcast(
+  Map<PluginInfo, Future<Response>> broadcastRequest(
       analyzer.ContextRoot contextRoot, RequestParams params) {
     List<PluginInfo> plugins = pluginsForContextRoot(contextRoot);
     Map<PluginInfo, Future<Response>> responseMap =
         <PluginInfo, Future<Response>>{};
     for (PluginInfo plugin in plugins) {
       responseMap[plugin] = plugin.currentSession?.sendRequest(params);
     }
     return responseMap;
   }
 
   /**
+   * Broadcast the given [watchEvent] to all of the plugins that are analyzing
+   * in contexts containing the file associated with the event. Return a list
+   * containing futures that will complete when each of the plugins have sent a
+   * response.
+   */
+  Future<List<Future<Response>>> broadcastWatchEvent(
+      watcher.WatchEvent watchEvent) async {

[scheglov, 2017/04/26 15:55:18]

Do we await it anywhere?
Or do we want to return the futures just in case?

Is there a reason to return separate futures instead of awaiting all of them
inside and return one (implicit) future?

[Brian Wilkerson, 2017/04/26 16:35:55]

It's useful in test code to allow us to know whether or not the plugin received
the request.
Only for consistency with broadcastRequest, which returns the individual
responses. Given that these responses will be empty (baring errors), that's a
fairly thin reason.

+    String filePath = watchEvent.path;
+
+    /**
+     * Return `true` if the given glob [pattern] matches the file being watched.
+     */
+    bool matches(String pattern) =>
+        new Glob(path.separator, pattern).matches(filePath);
+
+    WatchEvent event = null;
+    List<Future<Response>> responses = <Future<Response>>[];
+    for (PluginInfo plugin in _pluginMap.values) {
+      PluginSession session = plugin.currentSession;
+      if (session != null &&
+          path.isWithin(plugin.path, filePath) &&
+          session.interestingFiles.any(matches)) {
+        event ??= _convertWatchEvent(watchEvent);
+        AnalysisHandleWatchEventsParams params =
+            new AnalysisHandleWatchEventsParams([event]);
+        responses.add(session.sendRequest(params));
+      }
+    }
+    return responses;
+  }
+
+  /**
    * Return a list of all of the plugins that are currently associated with the
    * given [contextRoot].
    */
   @visibleForTesting
   List<PluginInfo> pluginsForContextRoot(analyzer.ContextRoot contextRoot) {
     List<PluginInfo> plugins = <PluginInfo>[];
     for (PluginInfo plugin in _pluginMap.values) {
       if (plugin.contextRoots.contains(contextRoot)) {
         plugins.add(plugin);
       }
@@ skipping 70 matching lines @@
     }
   }
 
   /**
    * Stop all of the plugins that are currently running.
    */
   Future<List<Null>> stopAll() {
     return Future.wait(_pluginMap.values.map((PluginInfo info) => info.stop()));
   }
 
+  WatchEventType _convertChangeType(watcher.ChangeType type) {
+    switch (type) {
+      case watcher.ChangeType.ADD:
+        return WatchEventType.ADD;
+      case watcher.ChangeType.MODIFY:
+        return WatchEventType.MODIFY;
+      case watcher.ChangeType.REMOVE:
+        return WatchEventType.REMOVE;
+      default:
+        throw new StateError('Unknown change type: $type');
+    }
+  }
+
+  WatchEvent _convertWatchEvent(watcher.WatchEvent watchEvent) {
+    return new WatchEvent(_convertChangeType(watchEvent.type), watchEvent.path);
+  }
+
   /**
    * Return the execution path and .packages path associated with the plugin at
    * the given [path], or `null` if there is a problem that prevents us from
    * executing the plugin.
    */
   List<String> _pathsFor(String pluginPath) {
     /**
      * Return `true` if the plugin in the give [folder] needs to be copied to a
      * temporary location so that 'pub' can be run to resolve dependencies. We
      * need to run `pub` if the plugin contains a `pubspec.yaml` file and is not
@@ skipping 137 matching lines @@
 
   /**
    * Return a future that will complete when the plugin has stopped.
    */
   Future<Null> get onDone => pluginStoppedCompleter.future;
 
   /**
    * Handle the given [notification].
    */
   void handleNotification(Notification notification) {
+    if (notification.event == PLUGIN_NOTIFICATION_ERROR) {
+      PluginErrorParams params =
+          new PluginErrorParams.fromNotification(notification);
+      if (params.isFatal) {
+        info.stop();
+        stop();
+      }
+    }
     info.notificationManager.handlePluginNotification(info.path, notification);
   }
 
   /**
    * Handle the fact that the plugin has stopped.
    */
   void handleOnDone() {
     channel.close();
     channel = null;
     pluginStoppedCompleter.complete(null);
@@ skipping 83 matching lines @@
   Future<Null> stop() {
     if (channel == null) {
       throw new StateError('Cannot stop a plugin that is not running.');
     }
     // TODO(brianwilkerson) Ensure that the isolate is killed if it does not
     // terminate normally.
     sendRequest(new PluginShutdownParams());
     return pluginStoppedCompleter.future;
   }
 }