Make HTTP server close sockets when closed in idle state

sdk/lib/io/http_impl.dart

 // Copyright (c) 2012, 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.
 
 // The close queue handles graceful closing of HTTP connections. When
 // a connection is added to the queue it will enter a wait state
 // waiting for all data written and possibly socket shutdown from
 // peer.
 class _CloseQueue {
   _CloseQueue() : _q = new Set<_HttpConnectionBase>();
 
   void add(_HttpConnectionBase connection) {
     void closeIfDone() {
       // We only check for write closed here. This means that we are
       // not waiting for the client to half-close the socket before
       // fully closing the socket.
       if (!connection._isWriteClosed) return;
       _q.remove(connection);
       connection._socket.close();
       if (connection.onClosed != null) connection.onClosed();
     }
 
     // If the connection is already fully closed don't insert it into the queue.
     if (connection._isFullyClosed) {
       connection._socket.close();
       if (connection.onClosed != null) connection.onClosed();
       return;
     }
 
+    connection._state |= _HttpConnectionBase.CLOSING;
     _q.add(connection);
 
     // If output stream is not closed for writing close it now and
     // wait for callback when closed.
     if (!connection._isWriteClosed) {
       connection._socket.outputStream.close();
       connection._socket.outputStream.onClosed = () {
         connection._state |= _HttpConnectionBase.WRITE_CLOSED;
         closeIfDone();
       };
     } else {
       connection._socket.outputStream.onClosed = () { assert(false); };
     }
 
     // If socket is not closed for reading wait for callback.
     if (!connection._isReadClosed) {
       connection._socket.onClosed = () {
         connection._state |= _HttpConnectionBase.READ_CLOSED;
         // This is a nop, as we are not using the read closed
         // information for anything. For both server and client
         // connections the inbound message have been read to
         // completion when the socket enters the close queue.
+        closeIfDone();
       };
     } else {
       connection._socket.onClosed = () { assert(false); };
     }
 
     // Ignore any data on a socket in the close queue.
     connection._socket.onData = connection._socket.read;
 
     // If an error occurs immediately close the socket.
     connection._socket.onError = (e) {
@@ skipping 649 matching lines @@
     _requestOrResponse._streamSetErrorHandler(callback);
   }
 
   _HttpRequestResponseBase _requestOrResponse;
 }
 
 
 abstract class _HttpConnectionBase {
   static const int IDLE = 0;
   static const int ACTIVE = 1;
-  static const int REQUEST_DONE = 2;
-  static const int RESPONSE_DONE = 4;
+  static const int CLOSING = 2;
+  static const int REQUEST_DONE = 4;
+  static const int RESPONSE_DONE = 8;
   static const int ALL_DONE = REQUEST_DONE | RESPONSE_DONE;
-  static const int READ_CLOSED = 8;
-  static const int WRITE_CLOSED = 16;
+  static const int READ_CLOSED = 16;
+  static const int WRITE_CLOSED = 32;
   static const int FULLY_CLOSED = READ_CLOSED | WRITE_CLOSED;
 
   _HttpConnectionBase() : hashCode = _nextHashCode {
     _nextHashCode = (_nextHashCode + 1) & 0xFFFFFFF;
   }
 
+  bool get _isIdle => (_state & ACTIVE) == 0;
+  bool get _isActive => (_state & ACTIVE) == ACTIVE;
+  bool get _isClosing => (_state & CLOSING) == CLOSING;
   bool get _isRequestDone => (_state & REQUEST_DONE) == REQUEST_DONE;
   bool get _isResponseDone => (_state & RESPONSE_DONE) == RESPONSE_DONE;
   bool get _isAllDone => (_state & ALL_DONE) == ALL_DONE;
   bool get _isReadClosed => (_state & READ_CLOSED) == READ_CLOSED;
   bool get _isWriteClosed => (_state & WRITE_CLOSED) == WRITE_CLOSED;
   bool get _isFullyClosed => (_state & FULLY_CLOSED) == FULLY_CLOSED;
 
   void _connectionEstablished(Socket socket) {
     _socket = socket;
     // Register handlers for socket events. All socket events are
@@ skipping 83 matching lines @@
     _httpParser.dataEnd = _onDataEnd;
     _httpParser.error = _onError;
     _httpParser.closed = _onClosed;
     _httpParser.responseStart = (statusCode, reasonPhrase, version) {
       assert(false);
     };
   }
 
   void _onClosed() {
     _state |= _HttpConnectionBase.READ_CLOSED;
+    _checkDone();
   }
 
   void _onError(e) {
     onError(e);
     // Propagate the error to the streams.
     if (_request != null && _request._streamErrorHandler != null) {
       _request._streamErrorHandler(e);
     }
     if (_response != null && _response._streamErrorHandler != null) {
       _response._streamErrorHandler(e);
@@ skipping 32 matching lines @@
       bool close =
           !_response.persistentConnection ||
           (_response._protocolVersion == "1.0" && _response._contentLength < 0);
       _request = null;
       _response = null;
       if (_isReadClosed || close) {
         _server._closeQueue.add(this);
       } else {
         _state = _HttpConnectionBase.IDLE;
       }
+    } else if (_state == _HttpConnectionBase.READ_CLOSED) {
+      // If entering READ_CLOSED state while idle close the connection.
+      _server._closeQueue.add(this);
     }
   }
 
   void _onDataEnd(bool close) {
     _request._onDataEnd();
     _state |= _HttpConnectionBase.REQUEST_DONE;
     _checkDone();
   }
 
   void _responseClosed() {
@@ skipping 120 matching lines @@
   }
 
   _HttpSessionManager get _sessionManager {
     // Lazy init.
     if (_sessionManagerInstance == null) {
       _sessionManagerInstance = new _HttpSessionManager();
     }
     return _sessionManagerInstance;
   }
 
+  HttpConnectionsInfo connectionsInfo() {
+    HttpConnectionsInfo result = new HttpConnectionsInfo();
+    result.total = _connections.length;
+    _connections.forEach((_HttpConnection conn) {
+      if (conn._isActive) {
+        result.active++;
+      } else if (conn._isIdle) {
+        result.idle++;
+      } else {
+        assert(result._isClosing);
+        result.closing++;
+      }
+    });
+    return result;
+  }
 
   ServerSocket _server;  // The server listen socket.
   bool _closeServer = false;
   Set<_HttpConnection> _connections;  // Set of currently connected clients.
   List<_RequestHandlerRegistration> _handlers;
   Object _defaultHandler;
   Function _onError;
   _CloseQueue _closeQueue;
   _HttpSessionManager _sessionManagerInstance;
 }
@@ skipping 391 matching lines @@
     _response = new _HttpClientResponse(this);
     return _request;
   }
 
   DetachedSocket detachSocket() {
     return _detachSocket();
   }
 
   void _onClosed() {
     _state |= _HttpConnectionBase.READ_CLOSED;
+    _checkSocketDone();
   }
 
   void _onError(e) {
     // Socket is closed either due to an error or due to normal socket close.
     if (_onErrorCallback != null) {
       _onErrorCallback(e);
     } else {
       throw e;
     }
     // Propagate the error to the streams.
@@ skipping 625 matching lines @@
 
 
 class _RedirectInfo implements RedirectInfo {
   const _RedirectInfo(int this.statusCode,
                       String this.method,
                       Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
 }