Add the ability to whitelist plugins

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;
@@ skipping 243 matching lines @@
    * The object used to manage the receiving and sending of notifications.
    */
   final NotificationManager notificationManager;
 
   /**
    * The instrumentation service that is being used by the analysis server.
    */
   final InstrumentationService instrumentationService;
 
   /**
+   * The list of globs used to match plugin paths that have been whitelisted.
+   */
+  List<Glob> _whitelistGlobs;
+
+  /**
    * A table mapping the paths of plugins to information about those plugins.
    */
   Map<String, PluginInfo> _pluginMap = <String, PluginInfo>{};
 
   /**
    * The parameters for the last 'analysis.setPriorityFiles' request that was
    * received from the client. Because plugins are lazily discovered, this needs
    * to be retained so that it can be sent after a plugin has been started.
    */
   AnalysisSetPriorityFilesParams _analysisSetPriorityFilesParams;
@@ skipping 10 matching lines @@
    * discovered, the state needs to be retained so that it can be sent after a
    * plugin has been started.
    */
   Map<String, dynamic> _overlayState = <String, dynamic>{};
 
   /**
    * Initialize a newly created plugin manager. The notifications from the
    * running plugins will be handled by the given [notificationManager].
    */
   PluginManager(this.resourceProvider, this.byteStorePath, this.sdkPath,
-      this.notificationManager, this.instrumentationService);
+      this.notificationManager, this.instrumentationService) {
+    // TODO(brianwilkerson) Figure out the right list of plugin paths.
+    _whitelistGlobs = <Glob>[
+      new Glob(resourceProvider.pathContext.separator,
+          '**/analyze_angular/tools/analysis_plugin')
+    ];
+  }
 
   /**
    * Add the plugin with the given [path] to the list of plugins that should be
    * used when analyzing code for the given [contextRoot]. If the plugin had not
    * yet been started, then it will be started by this method.
    */
   Future<Null> addPluginToContextRoot(
       analyzer.ContextRoot contextRoot, String path) async {
+    if (!_isWhitelisted(path)) {
+      return;
+    }
     PluginInfo plugin = _pluginMap[path];
     bool isNew = plugin == null;
     if (isNew) {
       List<String> pluginPaths = _pathsFor(path);
       if (pluginPaths == null) {
         return;
       }
       plugin = new DiscoveredPluginInfo(path, pluginPaths[0], pluginPaths[1],
           notificationManager, instrumentationService);
       _pluginMap[path] = plugin;
@@ skipping 155 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()));
   }
 
+  /**
+   * Whitelist all plugins.
+   */
+  @visibleForTesting
+  void whitelistEverything() {
+    _whitelistGlobs = <Glob>[
+      new Glob(resourceProvider.pathContext.separator, '**/*')
+    ];
+  }
+
   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 `true` if the plugin with the given [path] has been whitelisted.
+   */
+  bool _isWhitelisted(String path) {
+    for (Glob glob in _whitelistGlobs) {
+      if (glob.matches(path)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
    * 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
      * in a workspace.
@@ skipping 250 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;
   }
 }