Add error handling to the HTTP library

runtime/bin/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.
 
 class _HttpRequestResponseBase {
   _HttpRequestResponseBase(_HttpConnectionBase this._httpConnection)
       : _contentLength = -1,
         _keepAlive = false,
         _headers = new Map();
 
@@ skipping 161 matching lines @@
 
   List<int> _streamRead(int bytesToRead) {
     return _buffer.readBytes(bytesToRead);
   }
 
   int _streamReadInto(List<int> buffer, int offset, int len) {
     List<int> data = _buffer.readBytes(len);
     buffer.setRange(offset, data.length, data);
   }
 
+  void _streamSetErrorHandler(callback(Exception e)) {
+    _streamErrorHandler = callback
+  }
+
   String _method;
   String _uri;
   String _path;
   String _queryString;
   Map<String, String> _queryParameters;
   _HttpInputStream _inputStream;
   _BufferList _buffer;
+  Function _streamErrorHandler;
 }
 
 
 // HTTP response object for sending a HTTP response.
 class _HttpResponse extends _HttpRequestResponseBase implements HttpResponse {
   static final int START = 0;
   static final int HEADERS_SENT = 1;
   static final int DONE = 2;
 
   _HttpResponse(_HttpConnection httpConnection)
@@ skipping 82 matching lines @@
   void _streamSetNoPendingWriteHandler(callback()) {
     if (_state != DONE) {
       _httpConnection.outputStream.onNoPendingWrites = callback;
     }
   }
 
   void _streamSetCloseHandler(callback()) {
     // TODO(sgjesse): Handle this.
   }
 
-  void _streamSetErrorHandler(callback()) {
-    // TODO(sgjesse): Handle this.
+  void _streamSetErrorHandler(callback(Exception e)) {
+    _streamErrorHandler = callback
   }
 
   String _findReasonPhrase(int statusCode) {
     if (_reasonPhrase != null) {
       return _reasonPhrase;
     }
 
     switch (statusCode) {
       case HttpStatus.CONTINUE: return "Continue";
       case HttpStatus.SWITCHING_PROTOCOLS: return "Switching Protocols";
@@ skipping 74 matching lines @@
     _state = HEADERS_SENT;
     return allWritten;
   }
 
   // Response status code.
   int _statusCode;
   String _reasonPhrase;
   Date _expires;
   _HttpOutputStream _outputStream;
   int _state;
+  Function _streamErrorHandler;
 }
 
 
 class _HttpInputStream extends _BaseDataInputStream implements InputStream {
   _HttpInputStream(_HttpRequestResponseBase this._requestOrResponse) {
     _checkScheduleCallbacks();
   }
 
   int available() {
     return _requestOrResponse._streamAvailable();
   }
 
   void pipe(OutputStream output, [bool close = true]) {
     _pipe(this, output, close: close);
   }
 
   List<int> _read(int bytesToRead) {
     List<int> result = _requestOrResponse._streamRead(bytesToRead);
     _checkScheduleCallbacks();
     return result;
   }
 
+  void set onError(void callback(Exception e)) {
+    _requestOrResponse._streamSetErrorHandler(callback);
+  }
+
   int _readInto(List<int> buffer, int offset, int len) {
     int result = _requestOrResponse._streamReadInto(buffer, offset, len);
     _checkScheduleCallbacks();
     return result;
   }
 
   void _close() {
     // TODO(sgjesse): Handle this.
   }
 
@@ skipping 25 matching lines @@
   }
 
   void set onNoPendingWrites(void callback()) {
     _requestOrResponse._streamSetNoPendingWriteHandler(callback);
   }
 
   void set onClosed(void callback()) {
     _requestOrResponse._streamSetCloseHandler(callback);
   }
 
-  void set onError(void callback()) {
+  void set onError(void callback(Exception e)) {
     _requestOrResponse._streamSetErrorHandler(callback);
   }
 
   _HttpRequestResponseBase _requestOrResponse;
 }
 
 
 class _HttpConnectionBase implements Hashable {
   static final int PHASE_IDLE = 0;
   static final int PHASE_REQUEST = 1;
@@ skipping 38 matching lines @@
       // for writing the response.
       _closing = true;
     } else {
       // The connection is currently not used by any request just close it.
       _socket.close();
     }
     if (_onDisconnectCallback != null) _onDisconnectCallback();
   }
 
   void _onError(Exception e) {
-    // If an error occours, treat the socket as closed.
-    _onClosed();
+    // If an error occurs, make sure to close the socket if one is associated.
+    if (_socket != null) {
+      _socket.close();
+    }
     if (_onErrorCallback != null) {
-      _onErrorCallback("Connection closed while sending data to client ($e).");
+      _onErrorCallback(e);
     }
+    _subOnError(e);

[Mads Ager (google), 2012/03/22 14:30:08]

You called this something like _propagateError in a previous change. Use that
here as well? I liked that name better. :)

[Søren Gjesse, 2012/03/23 07:34:20]

Done. Sorry for the strange name.

   }
 
+  abstract void _subOnError(Exception e);
+
   void set onDisconnect(void callback()) {
     _onDisconnectCallback = callback;
   }
 
-  void set onError(void callback(String errorMessage)) {
+  void set onError(void callback(Exception e)) {
     _onErrorCallback = callback;
   }
 
   int hashCode() => _socket.hashCode();
 
   int _phase;
   Socket _socket;
   bool _closing = false;  // Is the socket closed by the client?
   _HttpParser _httpParser;
 
   Queue _sendBuffers;
 
   Function _onDisconnectCallback;
   Function _onErrorCallback;
 }
 
 
 // HTTP server connection over a socket.
 class _HttpConnection extends _HttpConnectionBase {
-  _HttpConnection() {
+  _HttpConnection(HttpServer this._server) {
     // Register HTTP parser callbacks.
     _httpParser.requestStart =
         (method, uri) => _onRequestStart(method, uri);
     _httpParser.responseStart =
         (statusCode, reasonPhrase) =>
             _onResponseStart(statusCode, reasonPhrase);
     _httpParser.headerReceived =
         (name, value) => _onHeaderReceived(name, value);
     _httpParser.headersComplete = () => _onHeadersComplete();
     _httpParser.dataReceived = (data) => _onDataReceived(data);
     _httpParser.dataEnd = () => _onDataEnd();
+    _httpParser.error = (e) => _onError(e);
   }
 
   void _onRequestStart(String method, String uri) {
     // Create new request and response objects for this request.
     _phase = PHASE_REQUEST;
     _request = new _HttpRequest(this);
     _response = new _HttpResponse(this);
     _request._onRequestStart(method, uri);
   }
 
@@ skipping 19 matching lines @@
 
   void _onDataEnd() {
     // Phase might already have gone to PHASE_IDLE if the response is
     // sent without waiting for request body.
     if (_phase == PHASE_REQUEST) {
       _phase = PHASE_RESPONSE;
     }
     _request._onDataEnd();
   }
 
+  void _subOnError(Exception e) {
+    if (_server._onError != null) {
+      _server._onError(e);
+    }
+    if (_request != null && _request._streamErrorHandler != null) {
+      _request._streamErrorHandler(e);
+    }
+    if (_response != null && _response._streamErrorHandler != null) {
+      _response._streamErrorHandler(e);
+    }
+  }
+
+  HttpServer _server;
   HttpRequest _request;
   HttpResponse _response;
 
   // Callbacks.
   var requestReceived;
 }
 
 
 // HTTP server waiting for socket connections. The connections are
 // managed by the server and as requests are received the request.
 class _HttpServer implements HttpServer {
   void listen(String host, int port, [int backlog = 5]) {
 
     void onConnection(Socket socket) {
       // Accept the client connection.
-      _HttpConnection connection = new _HttpConnection();
+      _HttpConnection connection = new _HttpConnection(this);
       connection._connectionEstablished(socket);
       connection.requestReceived = _onRequest;
       _connections.add(connection);
-      void onDisconnect() {
-        _connections.remove(connection);
-      }
-      connection.onDisconnect = onDisconnect;
-      void onError(String errorMessage) {
-        if (_onError != null) _onError(errorMessage);
-      }
-      connection.onError = onError;
+      connection.onDisconnect = () => _connections.remove(connection);
+      connection.onError = (e) {
+        if (_onError != null) _onError(e);
+      };
     }
 
     _connections = new Set<_HttpConnection>();
     _server = new ServerSocket(host, port, backlog);
     _server.onConnection = onConnection;
   }
 
   void close() {
     _server.close();
     for (_HttpConnection connection in _connections) {
       connection._socket.close();
     }
   }
 
   int get port() => _server.port;
 
-  void set onError(void handler(String errorMessage)) {
-    _onError = handler;
+  void set onError(void callback(Exception e)) {
+    _onError = callback;
   }
 
-  void set onRequest(void handler(HttpRequest, HttpResponse)) {
-    _onRequest = handler;
+  void set onRequest(void callback(HttpRequest, HttpResponse)) {
+    _onRequest = callback;
   }
 
   ServerSocket _server;  // The server listen socket.
   Set<_HttpConnection> _connections;  // Set of currently connected clients.
   Function _onRequest;
   Function _onError;
 }
 
 
 class _HttpClientRequest
@@ skipping 92 matching lines @@
   void _streamSetNoPendingWriteHandler(callback()) {
     if (_state != DONE) {
       _httpConnection.outputStream.onNoPendingWrites = callback;
     }
   }
 
   void _streamSetCloseHandler(callback()) {
     // TODO(sgjesse): Handle this.
   }
 
-  void _streamSetErrorHandler(callback()) {
-    // TODO(sgjesse): Handle this.
+  void _streamSetErrorHandler(callback(Exception e)) {
+    _streamErrorHandler = callback;
   }
 
   void _writeHeader() {
     List<int> data;
     OutputStream stream = _httpConnection.outputStream;
 
     // Write request line.
     data = _method.toString().charCodes();
     stream.write(data);
     _writeSP();
@@ skipping 19 matching lines @@
     _state = HEADERS_SENT;
   }
 
   String _method;
   String _uri;
   String _host;
   int _port;
   _HttpClientConnection _connection;
   _HttpOutputStream _outputStream;
   int _state;
+  Function _streamErrorHandler;
 }
 
 
 class _HttpClientResponse
     extends _HttpRequestResponseBase implements HttpClientResponse {
   _HttpClientResponse(_HttpClientConnection connection)
       : super(connection) {
     _connection = connection;
   }
 
@@ skipping 52 matching lines @@
   List<int> _streamRead(int bytesToRead) {
     return _buffer.readBytes(bytesToRead);
   }
 
   int _streamReadInto(List<int> buffer, int offset, int len) {
     List<int> data = _buffer.readBytes(len);
     buffer.setRange(offset, data.length, data);
     return data.length;
   }
 
+  void _streamSetErrorHandler(callback(Exception e)) {
+    _streamErrorHandler = callback;
+  }
+
   int _statusCode;
   String _reasonPhrase;
 
   _HttpClientConnection _connection;
   _HttpInputStream _inputStream;
   _BufferList _buffer;
+  Function _streamErrorHandler;
 }
 
 
 class _HttpClientConnection
     extends _HttpConnectionBase implements HttpClientConnection {
   _HttpClientConnection(_HttpClient this._client);
 
   void _connectionEstablished(_SocketConnection socketConn) {
     super._connectionEstablished(socketConn._socket);
     _socketConn = socketConn;
     // Register HTTP parser callbacks.
     _httpParser.requestStart =
         (method, uri) => _onRequestStart(method, uri);
     _httpParser.responseStart =
         (statusCode, reasonPhrase) =>
             _onResponseStart(statusCode, reasonPhrase);
     _httpParser.headerReceived =
         (name, value) => _onHeaderReceived(name, value);
     _httpParser.headersComplete = () => _onHeadersComplete();
     _httpParser.dataReceived = (data) => _onDataReceived(data);
     _httpParser.dataEnd = () => _onDataEnd();
+    _httpParser.error = (e) => _onError(e);
     // Tell the HTTP parser the method it is expecting a response to.
     _httpParser.responseToMethod = _method;
 
     onDisconnect = _onDisconnected;
   }
 
+  void _subOnError(Exception e) {
+    if (_response._streamErrorHandler != null) {
+      _response._streamErrorHandler(e);
+    }
+  }
+
   HttpClientRequest open(String method, String uri) {
     _method = method;
     _request = new _HttpClientRequest(method, uri, this);
     _request.keepAlive = true;
     _response = new _HttpClientResponse(this);
     return _request;
   }
 
   void _onRequestStart(String method, String uri) {
     // TODO(sgjesse): Error handling.
@@ skipping 14 matching lines @@
   void _onDataReceived(List<int> data) {
     _response._onDataReceived(data);
   }
 
   void _onDataEnd() {
     onDisconnect = null;
     if (_response.headers["connection"] == "close") {
       _socket.close();
     } else {
       _client._returnSocketConnection(_socketConn);
-      _socket = null;
-      _socketConn = null;
     }
+    _socket = null;
+    _socketConn = null;
     _response._onDataEnd();
   }
 
   void set onRequest(void handler(HttpClientRequest request)) {
     _onRequest = handler;
   }
 
   void set onResponse(void handler(HttpClientResponse response)) {
     _onResponse = handler;
   }
 
   void _onDisconnected() {
     if (_onErrorCallback !== null) {
       _onErrorCallback(new HttpException(
           "Client disconnected before response was received."));
     }
   }
 
-
   Function _onRequest;
   Function _onResponse;
 
   _HttpClient _client;
   _SocketConnection _socketConn;
   HttpClientRequest _request;
   HttpClientResponse _response;
   String _method;
 
   // Callbacks.
   var requestReceived;
-
 }
 
 
 // Class for holding keep-alive sockets in the cache for the HTTP
 // client together with the connection information.
 class _SocketConnection {
   _SocketConnection(String this._host,
                     int this._port,
                     Socket this._socket);
 
@@ skipping 97 matching lines @@
       }
     }
 
     _HttpClientConnection connection = new _HttpClientConnection(this);
 
     // If there are active connections for this key get the first one
     // otherwise create a new one.
     Queue socketConnections = _openSockets[_connectionKey(host, port)];
     if (socketConnections == null || socketConnections.isEmpty()) {
       Socket socket = new Socket(host, port);
       socket.onConnect = () {

[Mads Ager (google), 2012/03/22 14:30:08]

I think it would read better if you move the onError assignment before the
onConnect assignment?

Then the comments would be:

// Until the connection is established ...
onError = handleError
// When the connection is established ...
onConnect = handleConnect

Not really important though.

[Søren Gjesse, 2012/03/23 07:34:20]

Done.

+        // Clear the error callback as it will now be handled by the

[Mads Ager (google), 2012/03/22 14:30:08]

When the connection is established, clear the ...

[Søren Gjesse, 2012/03/23 07:34:20]

Done.

+        // HttpClientConnection object which will be associated with
+        // the connected socket.
         socket.onError = null;
         _SocketConnection socketConn =
             new _SocketConnection(host, port, socket);
         _activeSockets.add(socketConn);
         _connectionOpened(socketConn, connection);
       };
+      // Until the connection is established handle connection errors
+      // here as the HttpClientConnection object is not yet associated
+      // with the socket.
       socket.onError = (Exception e) {
-        if (_onError !== null) {
-          _onError(HttpStatus.NETWORK_CONNECT_TIMEOUT_ERROR);
-        }
+        // Report the error through the HttpClientConnection object to
+        // the client.
+        connection._onError(e);
       };
     } else {
       _SocketConnection socketConn = socketConnections.removeFirst();
       _activeSockets.add(socketConn);
       new Timer(0, (ignored) => _connectionOpened(socketConn, connection));
 
       // Get rid of eviction timer if there are no more active connections.
       if (socketConnections.isEmpty()) {
         _evictionTimer.cancel();
         _evictionTimer = null;
@@ skipping 40 matching lines @@
       }
       _evictionTimer = new Timer.repeating(10000, _handleEviction);
     }
 
     // Return connection.
     _activeSockets.remove(socketConn);
     sockets.addFirst(socketConn);
     socketConn._markReturned();
   }
 
-  void set onError(void callback(int status)) {
-    _onError = callback;
-  }
-
   Function _onOpen;
-  Function _onError;
   Map<String, Queue<_SocketConnection>> _openSockets;
   Set<_SocketConnection> _activeSockets;
   Timer _evictionTimer;
   bool _shutdown;  // Has this HTTP client been shutdown?
 }