Rework error handling in the service protocol and in Observatory.

runtime/observatory/lib/service_common.dart

 // Copyright (c) 2014, 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 service_common;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:typed_data';
 
@@ skipping 98 matching lines @@
   void _notifyDisconnect(String reason) {
     if (!_hasFinishedConnect) {
       return;
     }
     if (!_disconnected.isCompleted) {
       Logger.root.info('WebSocketVM connection error: ${target.networkAddress}');
       _disconnected.complete(reason);
     }
   }
   Future get onDisconnect => _disconnected.future;
+  bool get isDisconnected => _disconnected.isCompleted;
 
   void disconnect({String reason : 'WebSocket closed'}) {
     if (_hasInitiatedConnect) {
       _webSocket.close();
     }
     // We don't need to cancel requests and notify here.  These
     // functions will be called again when the onClose callback
     // fires. However, we may have a better 'reason' string now, so
     // let's take care of business.
     _cancelAllRequests(reason);
     _notifyDisconnect(reason);
   }
 
   Future<Map> invokeRpcRaw(String method, Map params) {
     if (!_hasInitiatedConnect) {
       _hasInitiatedConnect = true;
       _webSocket.connect(
           target.networkAddress, _onOpen, _onMessage, _onError, _onClose);
     }
+    if (_disconnected.isCompleted) {
+      // This connection was closed already.
+      var exception = new NetworkRpcException('WebSocket closed');
+      return new Future.error(exception);
+    }
     String serial = (_requestSerial++).toString();
     var request = new _WebSocketRequest(method, params);
     if (_webSocket.isOpen) {
       // Already connected, send request immediately.
       _sendRequest(serial, request);
     } else {
       // Not connected yet, add to delayed requests.
       _delayedRequests[serial] = request;
     }
     return request.completer.future;
@@ skipping 18 matching lines @@
     _sendAllDelayedRequests();
     _notifyConnect();
   }
 
   Map _parseJSON(String message) {
     var map;
     try {
       map = JSON.decode(message);
     } catch (e, st) {
       Logger.root.severe('Disconnecting: Error decoding message: $e\n$st');
-      disconnect(reason:'Error decoding JSON message: $e');
+      disconnect(reason:'Connection saw corrupt JSON message: $e');
       return null;
     }
     if (map == null) {
       Logger.root.severe("Disconnecting: Unable to decode 'null' message");
-      disconnect(reason:"Unable to decode 'null' message");
+      disconnect(reason:"Connection saw 'null' message");
       return null;
     }
     return map;
   }
 
   void _onBinaryMessage(dynamic data) {
     _webSocket.nonStringToByteData(data).then((ByteData bytes) {
       // See format spec. in VMs Service::SendEvent.
       int offset = 0;
       // Dart2JS workaround (no getUint64). Limit to 4 GB metadata.
@@ skipping 22 matching lines @@
       return;
     }
     var event = map['event'];
     if (event != null) {
       postServiceEvent(event, null);
       return;
     }
 
     // Extract serial and result.
     var serial = map['id'];
-    var result = map['result'];
 
     // Complete request.
     var request = _pendingRequests.remove(serial);
     if (request == null) {
       Logger.root.severe('Received unexpected message: ${map}');
       return;
     }
     if (request.method != 'getTagProfile' &&
         request.method != 'getIsolateMetric' &&
         request.method != 'getVMMetric') {
       Logger.root.info(
           'RESPONSE [${serial}] ${request.method}');
     }
-    request.completer.complete(result);
+
+    var result = map['result'];
+    if (result != null) {
+      request.completer.complete(result);
+    } else {
+      var exception = new ServerRpcException.fromMap(map['error']);
+      request.completer.completeError(exception);
+    }
   }
 
   // WebSocket message event handler.
   void _onMessage(dynamic data) {
     if (data is! String) {
       _onBinaryMessage(data);
     } else {
       _onStringMessage(data);
     }
   }
 
-  Map _generateNetworkError(String userMessage) {
-    var response = {
-      'type': 'ServiceException',
-      'kind': 'ConnectionClosed',
-      'message': userMessage,
-    };
-    return response;
-  }
-
   void _cancelRequests(Map<String,_WebSocketRequest> requests,
-                       String reason) {
+                       String message) {
     requests.forEach((_, _WebSocketRequest request) {
-      request.completer.complete(
-          _generateNetworkError(reason));
+      var exception = new NetworkRpcException(message);
+      request.completer.completeError(exception);
     });
     requests.clear();
   }
 
   /// Cancel all pending and delayed requests by completing them with an error.
   void _cancelAllRequests(String reason) {
+    String message = 'Canceling request: $reason';
     if (_pendingRequests.length > 0) {
-      Logger.root.info('Cancelling all pending requests.');
-      _cancelRequests(_pendingRequests, reason);
+      Logger.root.info('Canceling all pending requests.');
+      _cancelRequests(_pendingRequests, message);
     }
     if (_delayedRequests.length > 0) {
-      Logger.root.info('Cancelling all delayed requests.');
-      _cancelRequests(_delayedRequests, reason);
+      Logger.root.info('Canceling all delayed requests.');
+      _cancelRequests(_delayedRequests, message);
     }
   }
 
   /// Send all delayed requests.
   void _sendAllDelayedRequests() {
     assert(_webSocket.isOpen);
     if (_delayedRequests.length == 0) {
       return;
     }
     Logger.root.info('Sending all delayed requests.');
@@ skipping 28 matching lines @@
     if (request.method != 'getTagProfile' &&
         request.method != 'getIsolateMetric' &&
         request.method != 'getVMMetric') {
       Logger.root.info(
           'GET [${serial}] ${request.method}(${request.params}) from ${target.networkAddress}');
     }
     // Send message.
     _webSocket.send(message);
   }
 }