Add IO service object handler, with initial implementation for HTTP server.

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 2017 matching lines @@
   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;
 }
 
 
 // HTTP server waiting for socket connections.
-class _HttpServer extends Stream<HttpRequest> implements HttpServer {
+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>();
+
+  final String _serviceTypePath = 'io/http/servers';
+  final String _serviceTypeName = 'HttpServer';
+
   String serverHeader;
 
   Duration _idleTimeout;
   Timer _idleTimer;
 
   static Future<HttpServer> bind(address, int port, int backlog) {
     return ServerSocket.bind(address, port, backlog: backlog).then((socket) {
       return new _HttpServer._(socket, true);
     });
   }
@@ skipping 11 matching lines @@
         requestClientCertificate: requestClientCertificate)
         .then((socket) {
           return new _HttpServer._(socket, true);
         });
   }
 
   _HttpServer._(this._serverSocket, this._closeServer) {
     _controller = new StreamController<HttpRequest>(sync: true,
                                                     onCancel: close);
     idleTimeout = const Duration(seconds: 120);
+    _servers[_serviceId] = this;
   }
 
   _HttpServer.listenOn(this._serverSocket) : _closeServer = false {
     _controller = new StreamController<HttpRequest>(sync: true,
                                                     onCancel: close);
     idleTimeout = const Duration(seconds: 120);
+    _servers[_serviceId] = this;
   }
 
   Duration get idleTimeout => _idleTimeout;
 
   void set idleTimeout(Duration duration) {
     if (_idleTimer != null) {
       _idleTimer.cancel();
       _idleTimer = null;
     }
     _idleTimeout = duration;
@@ skipping 46 matching lines @@
     idleTimeout = null;
     if (force) {
       for (var c in _activeConnections.toList()) {
         c.destroy();
       }
       assert(_activeConnections.isEmpty);
     }
     for (var c in _idleConnections.toList()) {
       c.destroy();
     }
-    _maybeCloseSessionManager();
+    _maybePerformCleanup();
     return result;
   }
 
-  void _maybeCloseSessionManager() {
+  void _maybePerformCleanup() {
     if (closed &&
         _idleConnections.isEmpty &&
         _activeConnections.isEmpty &&
         _sessionManagerInstance != null) {
       _sessionManagerInstance.close();
       _sessionManagerInstance = null;
+      _servers.remove(_serviceId);
     }
   }
 
   int get port {
     if (closed) throw new HttpException("HttpServer is not bound to a socket");
     return _serverSocket.port;
   }
 
   InternetAddress get address {
     if (closed) throw new HttpException("HttpServer is not bound to a socket");
     return _serverSocket.address;
   }
 
   set sessionTimeout(int timeout) {
     _sessionManager.sessionTimeout = timeout;
   }
 
   void _handleRequest(HttpRequest request) => _controller.add(request);
 
   void _handleError(error) {
     if (!closed) _controller.addError(error);
   }
 
   void _connectionClosed(_HttpConnection connection) {
     // Remove itself from either idle or active connections.
     connection.unlink();
-    _maybeCloseSessionManager();
+    _maybePerformCleanup();
   }
 
   void _markIdle(_HttpConnection connection) {
     _activeConnections.remove(connection);
     _idleConnections.add(connection);
   }
 
   void _markActive(_HttpConnection connection) {
     _idleConnections.remove(connection);
     _activeConnections.add(connection);
@@ skipping 18 matching lines @@
         result.closing++;
       }
     });
     _idleConnections.forEach((_HttpConnection conn) {
       result.idle++;
       assert(conn._isIdle);
     });
     return result;
   }
 
+  Map _toJSON(bool ref) {
+    var r = {
+      'id': _servicePath,
+      'type': _serviceType(ref),
+      'name': '${address.host}:$port',
+      'user_name': '${address.host}:$port',
+    };
+    if (ref) {
+      return r;
+    }
+    r['port'] = port;
+    r['address'] = address.host;
+    r['active'] = _activeConnections.length;
+    r['idle'] = _idleConnections.length;
+    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
   // SecureServerSocket.
   final _serverSocket;
   final bool _closeServer;
 
@@ skipping 408 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)';
 }