Provide an API to dart:developer to control the web server hosting the Service Protocol

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:developer' show ServiceProtocolInfo;
 import 'dart:isolate';
+import 'dart:math';
 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 isolateControlPort = new RawReceivePort();
 final RawReceivePort scriptLoadPort = new RawReceivePort();
 
 abstract class IsolateEmbedderData {
   void cleanup();
 }
 
+String _makeAuthToken() {
+  final kTokenByteSize = 8;
+  Uint8List bytes = new Uint8List(kTokenByteSize);
+  Random random = new Random.secure();
+  for (int i = 0; i < kTokenByteSize; i++) {
+    bytes[i] = random.nextInt(256);
+  }
+  return BASE64URL.encode(bytes);
+}
+
+// The randomly generated auth token used to access the VM service.
+final String serviceAuthToken = _makeAuthToken();
+
 // 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 kFeatureDisabled           = 100;
@@ skipping 79 matching lines @@
 
 /// Called to write a stream into a file.
 typedef Future WriteStreamFileCallback(Uri path, Stream<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);
 
+/// Called when we need information about the server.
+typedef Future<Uri> ServerInformationCallback();
+
+/// Called when we want to [enable] or disable the web server.
+typedef Future<Uri> WebServerControlCallback(bool enable);
+
 /// 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 WriteStreamFileCallback writeStreamFile;
   static ReadFileCallback readFile;
   static ListFilesCallback listFiles;
+  static ServerInformationCallback serverInformation;
+  static WebServerControlCallback webServerControl;
 }
 
 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();
@@ skipping 38 matching lines @@
       case Constants.ISOLATE_SHUTDOWN_MESSAGE_ID:
         runningIsolates.isolateShutdown(portId, sp);
         IsolateEmbedderData ied = isolateEmbedderData.remove(portId);
         if (ied != null) {
           ied.cleanup();
         }
       break;
     }
   }
 
+  Future<Null> _serverMessageHandler(int code, SendPort sp, bool enable) async {
+    switch (code) {
+      case Constants.WEB_SERVER_CONTROL_MESSAGE_ID:
+        if (VMServiceEmbedderHooks.webServerControl == null) {
+          sp.send(null);
+          return;
+        }
+        Uri uri = await VMServiceEmbedderHooks.webServerControl(enable);
+        sp.send(uri);
+      break;
+      case Constants.SERVER_INFO_MESSAGE_ID:
+        if (VMServiceEmbedderHooks.serverInformation == null) {
+          sp.send(null);
+          return;
+        }
+        Uri uri = await VMServiceEmbedderHooks.serverInformation();
+        sp.send(uri);
+      break;
+    }
+  }
+
   Future _exit() async {
     // Stop the server.
     if (VMServiceEmbedderHooks.serverStop != null) {
       await VMServiceEmbedderHooks.serverStop();
     }
 
     // Close receive ports.
-    isolateLifecyclePort.close();
+    isolateControlPort.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) {
@@ skipping 11 matching lines @@
         assert(message[1] is String || message[1] is Uint8List);
         _eventMessageHandler(message);
         return;
       }
       if (message.length == 1) {
         // This is a control message directing the vm service to exit.
         assert(message[0] == Constants.SERVICE_EXIT_MESSAGE_ID);
         _exit();
         return;
       }
+      if (message.length == 3) {
+        // This is a message interacting with the web server.
+        assert((message[0] == Constants.WEB_SERVER_CONTROL_MESSAGE_ID) ||
+               (message[0] == Constants.SERVER_INFO_MESSAGE_ID));
+        _serverMessageHandler(message[0], message[1], message[2]);
+        return;
+      }
       if (message.length == 4) {
         // This is a message informing us of the birth or death of an
         // isolate.
         _controlMessageHandler(message[0], message[1], message[2], message[3]);
         return;
       }
     }
     print('Internal vm-service error: ignoring illegal message: $message');
   }
 
   VMService._internal()
-      : eventPort = isolateLifecyclePort {
+      : eventPort = isolateControlPort {
     eventPort.handler = messageHandler;
   }
 
   factory VMService() {
     if (VMService._instance == null) {
       VMService._instance = new VMService._internal();
       _onStart();
     }
     return _instance;
   }
@@ skipping 160 matching lines @@
       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;
+  // Return the port we expect isolate control messages on.
+  return isolateControlPort;
 }
 
 void _registerIsolate(int port_id, SendPort sp, String name) {
   var service = new VMService();
   service.runningIsolates.isolateStartup(port_id, sp, name);
 }
 
 /// Notify the VM that the service is running.
 external void _onStart();
 
 /// Notify the VM that the service is no longer running.
 external void _onExit();
 
 /// Notify the VM that the server's address has changed.
 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();
 
 /// Notify the vm service that an isolate has been spawned via rpc.
 external void _spawnUriNotify(obj, String token);