Add sessions to HttpServer.

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 _HttpHeaders implements HttpHeaders {
   _HttpHeaders() : _headers = new Map<String, List<String>>();
 
   List<String> operator[](String name) {
     name = name.toLowerCase();
     return _headers[name];
@@ skipping 835 matching lines @@
   InputStream get inputStream {
     if (_inputStream == null) {
       _inputStream = new _HttpInputStream(this);
       _inputStream._streamMarkedClosed = _dataEndCalled;
     }
     return _inputStream;
   }
 
   String get protocolVersion => _protocolVersion;
 
+  HttpSession session([init(HttpSession session)]) {
+    if (_session != null) {
+      // It's already mapped, use it.
+      return _session;
+    }
+    // Create session, store it in connection, and return.
+    var sessionManager = _httpConnection._server._sessionManager;
+    return _session = sessionManager.createSession(init);
+  }
+
   void _onRequestStart(String method, String uri, String version) {
     _method = method;
     _uri = uri;
     _parseRequestUri(uri);
   }
 
   void _onHeaderReceived(String name, String value) {
     _headers.add(name, value);
   }
 
   void _onHeadersComplete() {
+    if (_httpConnection._server._sessionManagerInstance != null) {

[Søren Gjesse, 2012/10/22 12:56:29]

Nice.

+      // Map to session if exists.
+      var sessionId = cookies.reduce(null, (last, cookie) {
+        if (last != null) return last;
+        return cookie.name.toUpperCase() == _DART_SESSION_ID ?
+            cookie.value : null;
+      });
+      if (sessionId != null) {
+        var sessionManager = _httpConnection._server._sessionManager;
+        _session = sessionManager.getSession(sessionId);
+        if (_session != null) {
+          _session._markSeen();
+        }
+      }
+    }
+
     _headers._mutable = false;
     // Prepare for receiving data.
     _buffer = new _BufferList();
   }
 
   void _onDataReceived(List<int> data) {
     _buffer.add(data);
     if (_inputStream != null) _inputStream._dataReceived();
   }
 
@@ skipping 37 matching lines @@
 
   String _method;
   String _uri;
   String _path;
   String _queryString;
   Map<String, String> _queryParameters;
   _HttpInputStream _inputStream;
   _BufferList _buffer;
   bool _dataEndCalled = false;
   Function _streamErrorHandler;
+  _HttpSession _session;
 }
 
 
 // HTTP response object for sending a HTTP response.
 class _HttpResponse extends _HttpRequestResponseBase implements HttpResponse {
   _HttpResponse(_HttpConnection httpConnection)
       : super(httpConnection),
         _statusCode = HttpStatus.OK;
 
   void set contentLength(int contentLength) {
@@ skipping 157 matching lines @@
     _writeCRLF();
 
     // Determine the value of the "Transfer-Encoding" header based on
     // whether the content length is known.
     if (_contentLength >= 0) {
       _headers.set(HttpHeaders.CONTENT_LENGTH, _contentLength.toString());
     } else if (_contentLength < 0) {
       _headers.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
     }
 
+    var session = _httpConnection._request._session;
+    if (session != null && !session._destroyed) {
+      // Make sure we only send the current session id.
+      bool found = false;
+      for (int i = 0; i < cookies.length; i++) {
+        if (cookies[i].name.toUpperCase() == _DART_SESSION_ID) {
+          cookie.value = session.id;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        cookies.add(new Cookie(_DART_SESSION_ID, session.id));
+      }
+    }
     // Add all the cookies set to the headers.
     if (_cookies != null) {
       _cookies.forEach((cookie) {
         _headers.add("set-cookie", cookie);
       });
     }
 
     // Write headers.
     bool allWritten = _writeHeaders();
     _state = HEADER_SENT;
@@ skipping 323 matching lines @@
   Function onError;
 }
 
 
 class _RequestHandlerRegistration {
   _RequestHandlerRegistration(Function this._matcher, Function this._handler);
   Function _matcher;
   Function _handler;
 }
 
-
 // HTTP server waiting for socket connections. The connections are
 // managed by the server and as requests are received the request.
 class _HttpServer implements HttpServer {
   _HttpServer() : _connections = new Set<_HttpConnection>(),
                   _handlers = new List<_RequestHandlerRegistration>();
 
   void listen(String host, int port, {int backlog: 128}) {
     listenOn(new ServerSocket(host, port, backlog));
     _closeServer = true;
   }
@@ skipping 25 matching lines @@
                     void handler(HttpRequest request, HttpResponse response)) {
     _handlers.add(new _RequestHandlerRegistration(matcher, handler));
   }
 
   void set defaultRequestHandler(
       void handler(HttpRequest request, HttpResponse response)) {
     _defaultHandler = handler;
   }
 
   void close() {
-    if (_server !== null && _closeServer) {
+    if (_sessionManagerInstance != null) {
+      _sessionManagerInstance.close();
+      _sessionManagerInstance = null;
+    }
+    if (_server != null && _closeServer) {
       _server.close();
     }
     _server = null;
     for (_HttpConnection connection in _connections) {
       connection._destroy();
     }
     _connections.clear();
   }
 
   int get port {
     if (_server === null) {
       throw new HttpException("The HttpServer is not listening on a port.");
     }
     return _server.port;
   }
 
   void set onError(void callback(e)) {
     _onError = callback;
   }
 
+  int set sessionTimeout(int timeout) {
+    _sessionManager.sessionTimeout = timeout;
+  }
+
   void _handleRequest(HttpRequest request, HttpResponse response) {
     for (int i = 0; i < _handlers.length; i++) {
       if (_handlers[i]._matcher(request)) {
         Function handler = _handlers[i]._handler;
         try {
           handler(request, response);
         } catch (e) {
           if (_onError != null) {
             _onError(e);
           } else {
             throw e;
           }
         }
         return;
       }
     }
 
     if (_defaultHandler != null) {
       _defaultHandler(request, response);
     } else {
       response.statusCode = HttpStatus.NOT_FOUND;
       response.contentLength = 0;
       response.outputStream.close();
     }
   }
 
+  _HttpSessionManager get _sessionManager {
+    // Lazy init.
+    if (_sessionManagerInstance == null) {
+      _sessionManagerInstance = new _HttpSessionManager();
+    }
+    return _sessionManagerInstance;
+  }
+
 
   ServerSocket _server;  // The server listen socket.
   bool _closeServer = false;
   Set<_HttpConnection> _connections;  // Set of currently connected clients.
   List<_RequestHandlerRegistration> _handlers;
   Object _defaultHandler;
   Function _onError;
+  _HttpSessionManager _sessionManagerInstance;
 }
 
 
 class _HttpClientRequest
     extends _HttpRequestResponseBase implements HttpClientRequest {
   _HttpClientRequest(String this._method,
                      Uri this._uri,
                      _HttpClientConnection connection)
       : super(connection) {
     _connection = connection;
@@ skipping 737 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;
 }