Add HttpServerConnection to Observatory.

sdk/lib/io/http_impl.dart

 // Copyright (c) 2013, 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.
 
 part of dart.io;
 
 const int _OUTGOING_BUFFER_SIZE = 8 * 1024;
 
 class _HttpIncoming extends Stream<List<int>> {
   final int _transferLength;
@@ skipping 1974 matching lines @@
         return proxyCfg;
       }
     }
     return "DIRECT";
   }
 
   static Map<String, String> _platformEnvironmentCache = Platform.environment;
 }
 
 
-class _HttpConnection extends LinkedListEntry<_HttpConnection> {
+class _HttpConnection
+    extends LinkedListEntry<_HttpConnection> with _ServiceObject {
   static const _ACTIVE = 0;
   static const _IDLE = 1;
   static const _CLOSING = 2;
   static const _DETACHED = 3;
 
-  final Socket _socket;
+  // Use HashMap, as we don't need to keep order.
+  static Map<int, _HttpConnection> _connections =
+      new HashMap<int, _HttpConnection>();
+
+  final _socket;
   final _HttpServer _httpServer;
   final _HttpParser _httpParser;
   int _state = _IDLE;
   StreamSubscription _subscription;
   Timer _idleTimer;
   bool _idleMark = false;
   Future _streamFuture;
 
   _HttpConnection(this._socket, this._httpServer)
       : _httpParser = new _HttpParser.requestParser() {
+    try { _socket._owner = this; } catch (_) { print(_); }
+    _connections[_serviceId] = this;
     _httpParser.listenToStream(_socket);
     _subscription = _httpParser.listen(
         (incoming) {
           _httpServer._markActive(this);
           // If the incoming was closed, close the connection.
           incoming.dataDone.then((closing) {
             if (closing) destroy();
           });
           // Only handle one incoming request at the time. Keep the
           // stream paused until the request has been send.
@@ skipping 45 matching lines @@
     _idleMark = true;
   }
 
   bool get isMarkedIdle => _idleMark;
 
   void destroy() {
     if (_state == _CLOSING || _state == _DETACHED) return;
     _state = _CLOSING;
     _socket.destroy();
     _httpServer._connectionClosed(this);
+    _connections.remove(_serviceId);
   }
 
   Future<Socket> detachSocket() {
     _state = _DETACHED;
     // Remove connection from server.
     _httpServer._connectionClosed(this);
 
     _HttpDetachedIncoming detachedIncoming = _httpParser.detachIncoming();
 
     return _streamFuture.then((_) {
+      _connections.remove(_serviceId);
       return new _DetachedSocket(_socket, detachedIncoming);
     });
   }
 
   HttpConnectionInfo get connectionInfo => _HttpConnectionInfo.create(_socket);
 
   bool get _isActive => _state == _ACTIVE;
   bool get _isIdle => _state == _IDLE;
   bool get _isClosing => _state == _CLOSING;
   bool get _isDetached => _state == _DETACHED;
+
+  String get _serviceTypePath => 'io/http/serverconnections';
+  String get _serviceTypeName => 'HttpServerConnection';
+
+  Map _toJSON(bool ref) {
+    var name = "${_socket.address.host}:${_socket.port} <-> "
+        "${_socket.remoteAddress.host}:${_socket.remotePort}";
+    var r = {
+      'id': _servicePath,
+      'type': _serviceType(ref),
+      'name': name,
+      'user_name': name,
+    };
+    if (ref) {
+      return r;
+    }
+    r['server'] = _httpServer._toJSON(true);
+    try {
+      r['socket'] = _socket._toJSON(true);
+    } catch (_) {
+      r['socket'] = {
+        'id': _servicePath,
+        'type': '@Socket',
+        'name': 'UserSocket',
+        'user_name': 'UserSocket',
+      };
+    }
+    switch (_state) {
+      case _ACTIVE: r['state'] = "Active"; break;
+      case _IDLE: r['state'] = "Idle"; break;
+      case _CLOSING: r['state'] = "Closing"; break;
+      case _DETACHED: r['state'] = "Detached"; break;
+      default: r['state'] = 'Unknown'; break;
+    }
+    return r;
+  }
 }
 
 
 // HTTP server waiting for socket connections.
 class _HttpServer
     extends Stream<HttpRequest> with _ServiceObject
     implements HttpServer {
   // Use default Map so we keep order.
   static Map<int, _HttpServer> _servers = new Map<int, _HttpServer>();
 
@@ skipping 209 matching lines @@
     } catch (_) {
       r['socket'] = {
         'id': _servicePath,
         'type': '@Socket',
         'name': 'UserSocket',
         'user_name': 'UserSocket',
       };
     }
     r['port'] = port;
     r['address'] = address.host;
-    r['active'] = _activeConnections.length;
-    r['idle'] = _idleConnections.length;
+    r['active'] = _activeConnections.map((c) => c._toJSON(true)).toList();
+    r['idle'] = _idleConnections.map((c) => c._toJSON(true)).toList();
     r['closed'] = closed;
     return r;
   }
 
   _HttpSessionManager _sessionManagerInstance;
 
   // Indicated if the http server has been closed.
   bool closed = false;
 
   // The server listen socket. Untyped as it can be both ServerSocket and
@@ skipping 415 matching lines @@
   const _RedirectInfo(this.statusCode, this.method, this.location);
 }
 
 String _getHttpVersion() {
   var version = Platform.version;
   // Only include major and minor version numbers.
   int index = version.indexOf('.', version.indexOf('.') + 1);
   version = version.substring(0, index);
   return 'Dart/$version (dart:io)';
 }