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([initSessions(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(initSessions);
+  }
+
   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() {
+    // Map to session if exists.

[Søren Gjesse, 2012/10/22 11:13:02]

There is a pay for non-use here. We run through the cookies even if sessions are
not used. Maybe this should be lazy, but of cause the markSeen call will then
only be used if the session is actually retrieved.

[Anders Johnsen, 2012/10/22 12:18:57]

I've changed so that we check the server if sessions are initialized.

+    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;
 }