Reimplement devfs in dart. Implementation now writes to disk.

sdk/lib/vmservice/vmservice.dart

 // Copyright (c) 2015, 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 dart._vmservice;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:isolate';
 import 'dart:typed_data';
 
 part 'asset.dart';
 part 'client.dart';
+part 'devfs.dart';
 part 'constants.dart';
 part 'running_isolate.dart';
 part 'running_isolates.dart';
 part 'message.dart';
 part 'message_router.dart';
 
 final RawReceivePort isolateLifecyclePort = new RawReceivePort();
 final RawReceivePort scriptLoadPort = new RawReceivePort();
 
 abstract class IsolateEmbedderData {
   void cleanup();
 }
 
 // This is for use by the embedder. It is a map from the isolateId to
 // anything implementing IsolateEmbedderData. When an isolate goes away,
 // the cleanup method will be invoked after being removed from the map.
 final Map<int, IsolateEmbedderData> isolateEmbedderData =
     new Map<int, IsolateEmbedderData>();
 
 // These must be kept in sync with the declarations in vm/json_stream.h.
-const kInvalidParams = -32602;
-const kInternalError = -32603;
-const kStreamAlreadySubscribed = 103;
-const kStreamNotSubscribed = 104;
+const kInvalidParams             = -32602;
+const kInternalError             = -32603;
+const kFeatureDisabled           = 100;
+const kStreamAlreadySubscribed   = 103;
+const kStreamNotSubscribed       = 104;
+const kFileSystemAlreadyExists   = 1001;
+const kFileSystemDoesNotExist    = 1002;
+const kFileDoesNotExist          = 1003;
 
 var _errorMessages = {
   kInvalidParams: 'Invalid params',
   kInternalError: 'Internal error',
+  kFeatureDisabled: 'Feature is disabled',
   kStreamAlreadySubscribed: 'Stream already subscribed',
   kStreamNotSubscribed: 'Stream not subscribed',
+  kFileSystemAlreadyExists: 'File system already exists',
+  kFileSystemDoesNotExist: 'File system does not exist',
+  kFileDoesNotExist: 'File does not exist',
 };
 
 String encodeRpcError(Message message, int code, {String details}) {
   var response = {
     'jsonrpc': '2.0',
     'id' : message.serial,
     'error' : {
       'code': code,
       'message': _errorMessages[code],
     },
   };
   if (details != null) {
     response['error']['data'] = {
       'details': details,
     };
   }
   return JSON.encode(response);
 }
 
+String encodeMissingParamError(Message message, String param) {
+  return encodeRpcError(
+      message, kInvalidParams,
+      details: "${message.method} expects the '${param}' parameter");
+}
+
+String encodeInvalidParamError(Message message, String param) {
+  var value = message.params[param];
+  return encodeRpcError(
+      message, kInvalidParams,
+      details: "${message.method}: invalid '${param}' parameter: ${value}");
+}
+
 String encodeResult(Message message, Map result) {
   var response = {
     'jsonrpc': '2.0',
     'id' : message.serial,
     'result' : result,
   };
   return JSON.encode(response);
 }
 
+String encodeSuccess(Message message) {
+  return encodeResult(message, { 'type': 'Success' });
+}
+
 const shortDelay = const Duration(milliseconds: 10);
 
 /// Called when the server should be started.
 typedef Future ServerStartCallback();
 
 /// Called when the server should be stopped.
 typedef Future ServerStopCallback();
 
 /// Called when the service is exiting.
 typedef Future CleanupCallback();
 
+/// Called to create a temporary directory
+typedef Future<Uri> CreateTempDirCallback(String base);
+
+/// Called to delete a directory
+typedef Future DeleteDirCallback(Uri path);
+
+/// Called to write a file.
+typedef Future WriteFileCallback(Uri path, List<int> bytes);
+
+/// Called to read a file.
+typedef Future<List<int>> ReadFileCallback(Uri path);
+
+/// Called to list all files under some path.
+typedef Future<List<Map<String,String>>> ListFilesCallback(Uri path);
+
 /// Hooks that are setup by the embedder.
 class VMServiceEmbedderHooks {
   static ServerStartCallback serverStart;
   static ServerStopCallback serverStop;
   static CleanupCallback cleanup;
+  static CreateTempDirCallback createTempDir;
+  static DeleteDirCallback deleteDir;
+  static WriteFileCallback writeFile;
+  static ReadFileCallback readFile;
+  static ListFilesCallback listFiles;
 }
 
 class VMService extends MessageRouter {
   static VMService _instance;
 
   /// Collection of currently connected clients.
   final Set<Client> clients = new Set<Client>();
 
   /// Collection of currently running isolates.
   RunningIsolates runningIsolates = new RunningIsolates();
 
   /// A port used to receive events from the VM.
   final RawReceivePort eventPort;
 
+  final _devfs = new DevFS();
+
   void _addClient(Client client) {
     assert(client.streams.isEmpty);
     clients.add(client);
   }
 
   void _removeClient(Client client) {
     clients.remove(client);
     for (var streamId in client.streams) {
       if (!_isAnyClientSubscribed(streamId)) {
         _vmCancelStream(streamId);
@@ skipping 38 matching lines @@
     // Close receive ports.
     isolateLifecyclePort.close();
     scriptLoadPort.close();
 
     // Create a copy of the set as a list because client.disconnect() will
     // alter the connected clients set.
     var clientsList = clients.toList();
     for (var client in clientsList) {
       client.disconnect();
     }
+    _devfs.cleanup();
     if (VMServiceEmbedderHooks.cleanup != null) {
       await VMServiceEmbedderHooks.cleanup();
     }
     // Notify the VM that we have exited.
     _onExit();
   }
 
   void messageHandler(message) {
     if (message is List) {
       if (message.length == 2) {
@@ skipping 50 matching lines @@
     }
     if (!_isAnyClientSubscribed(streamId)) {
       if (!_vmListenStream(streamId)) {
         return encodeRpcError(
             message, kInvalidParams,
             details:"streamListen: invalid 'streamId' parameter: ${streamId}");
       }
     }
     client.streams.add(streamId);
 
-    var result = { 'type' : 'Success' };
-    return encodeResult(message, result);
+    return encodeSuccess(message);
   }
 
   Future<String> _streamCancel(Message message) async {
     var client = message.client;
     var streamId = message.params['streamId'];
 
     if (!client.streams.contains(streamId)) {
       return encodeRpcError(message, kStreamNotSubscribed);
     }
     client.streams.remove(streamId);
     if (!_isAnyClientSubscribed(streamId)) {
       _vmCancelStream(streamId);
     }
 
-    var result = { 'type' : 'Success' };
-    return encodeResult(message, result);
+    return encodeSuccess(message);
   }
 
   // TODO(johnmccutchan): Turn this into a command line tool that uses the
   // service library.
   Future<String> _getCrashDump(Message message) async {
     var client = message.client;
     final perIsolateRequests = [
         // ?isolateId=<isolate id> will be appended to each of these requests.
         // Isolate information.
         Uri.parse('getIsolate'),
@@ skipping 54 matching lines @@
     // TODO(turnidge): Update to json rpc.  BEFORE SUBMIT.
     if (message.method == '_getCrashDump') {
       return _getCrashDump(message);
     }
     if (message.method == 'streamListen') {
       return _streamListen(message);
     }
     if (message.method == 'streamCancel') {
       return _streamCancel(message);
     }
+    if (_devfs.shouldHandleMessage(message)) {
+      return _devfs.handleMessage(message);
+    }
     if (message.params['isolateId'] != null) {
       return runningIsolates.route(message);
     }
     return message.sendToVM();
   }
 }
 
 RawReceivePort boot() {
   // Return the port we expect isolate startup and shutdown messages on.
   return isolateLifecyclePort;
@@ skipping 14 matching lines @@
 external void onServerAddressChange(String address);
 
 /// Subscribe to a service stream.
 external bool _vmListenStream(String streamId);
 
 /// Cancel a subscription to a service stream.
 external void _vmCancelStream(String streamId);
 
 /// Get the bytes to the tar archive.
 external Uint8List _requestAssets();