Update plugin spec

pkg/analyzer_plugin/lib/plugin/plugin.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 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart'
     show AnalysisDriverScheduler, PerformanceLog;
+import 'package:analyzer/src/dart/analysis/file_byte_store.dart';
 import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer_plugin/channel/channel.dart';
 import 'package:analyzer_plugin/protocol/generated_protocol.dart';
 import 'package:analyzer_plugin/protocol/protocol.dart';
 import 'package:analyzer_plugin/protocol/protocol_constants.dart';
 import 'package:analyzer_plugin/src/protocol/protocol_internal.dart';
 import 'package:analyzer_plugin/src/utilities/null_string_sink.dart';
 import 'package:analyzer_plugin/utilities/subscription_manager.dart';
+import 'package:pub_semver/pub_semver.dart';
 
 /**
  * The abstract superclass of any class implementing a plugin for the analysis
  * server.
  *
  * Clients may not implement or mix-in this class, but are expected to extend
  * it.
  */
 abstract class ServerPlugin {
   /**
+   * A gigabyte.
+   */
+  static const int G = 1024 * 1024 * 1024;
+
+  /**
+   * A megabyte.
+   */
+  static const int M = 1024 * 1024;
+
+  /**
    * The communication channel being used to communicate with the analysis
    * server.
    */
   PluginCommunicationChannel _channel;
 
   /**
    * The resource provider used to access the file system.
    */
   final ResourceProvider resourceProvider;
 
   /**
    * The object used to manage analysis subscriptions.
    */
   final SubscriptionManager subscriptionManager = new SubscriptionManager();
 
   /**
    * The scheduler used by any analysis drivers that are created.
    */
   AnalysisDriverScheduler analysisDriverScheduler;
 
   /**
    * The performance log used by any analysis drivers that are created.
    */
   final PerformanceLog performanceLog =
       new PerformanceLog(new NullStringSink());
 
   /**
-   * The byte store used by any analysis drivers that are created.
+   * The byte store used by any analysis drivers that are created, or `null` if
+   * the cache location isn't known because the 'plugin.version' request has not
+   * yet been received.
    */
-  final ByteStore byteStore = new MemoryByteStore();
+  ByteStore _byteStore;
 
   /**
    * The file content overlay used by any analysis drivers that are created.
    */
   final FileContentOverlay fileContentOverlay = new FileContentOverlay();
 
   /**
    * Initialize a newly created analysis server plugin. If a resource [provider]
    * is given, then it will be used to access the file system. Otherwise a
    * resource provider that accesses the physical file system will be used.
    */
   ServerPlugin(this.resourceProvider) {
     analysisDriverScheduler = new AnalysisDriverScheduler(performanceLog);
   }
 
   /**
    * Return the communication channel being used to communicate with the
    * analysis server, or `null` if the plugin has not been started.
    */
   PluginCommunicationChannel get channel => _channel;
 
   /**
+   * Return the user visible information about how to contact the plugin authors
+   * with any problems that are found, or `null` if there is no contact info.
+   */
+  String get contactInfo => null;
+
+  /**
+   * Return a list of glob patterns selecting the files that this plugin is
+   * interested in analyzing.
+   */
+  List<String> get fileGlobsToAnalyze;
+
+  /**
+   * Return the user visible name of this plugin.
+   */
+  String get name;
+
+  /**
+   * Return the version number of this plugin, encoded as a string.
+   */
+  String get version;
+
+  /**
    * Handle the fact that the file with the given [path] has been modified.
    */
   void contentChanged(String path) {
     // Ignore changes to files.
   }
 
   /**
    * Handle an 'analysis.handleWatchEvents' request.
    */
   AnalysisHandleWatchEventsResult handleAnalysisHandleWatchEvents(
@@ skipping 130 matching lines @@
    * perform any required clean-up, but cannot prevent the plugin from shutting
    * down.
    */
   PluginShutdownResult handlePluginShutdown(Map<String, Object> parameters) =>
       new PluginShutdownResult();
 
   /**
    * Handle a 'plugin.versionCheck' request.
    */
   PluginVersionCheckResult handlePluginVersionCheck(
-      Map<String, Object> parameters);
+      Map<String, Object> parameters) {
+    String byteStorePath = validateParameter(parameters,
+        PLUGIN_REQUEST_VERSION_CHECK_BYTESTOREPATH, 'plugin.versionCheck');
+    String versionString = validateParameter(parameters,
+        PLUGIN_REQUEST_VERSION_CHECK_VERSION, 'plugin.versionCheck');
+    Version serverVersion = new Version.parse(versionString);
+    _byteStore =
+        new MemoryCachingByteStore(new FileByteStore(byteStorePath, G), 64 * M);

[scheglov, 2017/02/04 02:01:15]

We might want to avoid using FileByteStore in plugins.
We want to read and write to the same cache.
But FileByteStore also scans the cache directory and evicts older entries.
It is better to have one isolate that does this, in Analysis Server itself.
Let's discuss it on Monday.

[Brian Wilkerson, 2017/02/04 18:06:56]

Ah, I didn't realize it did that much. Could we pull the eviction into a
separate class (something like ByteStoreReaper) so that FileByteStore can be
re-used?

+    return new PluginVersionCheckResult(
+        isCompatibleWith(serverVersion), name, version, fileGlobsToAnalyze,
+        contactInfo: contactInfo);
+  }
+
+  /**
+   * Return `true` if this plugin is compatible with an analysis server that is
+   * using the given version of the plugin API.
+   */
+  bool isCompatibleWith(Version serverVersion) =>
+      serverVersion <= new Version.parse(version);
 
   /**
    * The method that is called when the analysis server closes the communication
    * channel. This method will not be invoked under normal conditions because
    * the server will send a shutdown request and the plugin will stop listening
    * to the channel before the server closes the channel.
    */
   void onDone() {}
 
   /**
@@ skipping 106 matching lines @@
       response = new Response(id,
           error: new RequestError(
               RequestErrorCode.PLUGIN_ERROR, exception.toString(),
               stackTrace: stackTrace.toString()));
     }
     if (response != null) {
       _channel.sendResponse(response);
     }
   }
 }