pkg/shelf - send Date header in shelf_io

pkg/shelf/lib/shelf_io.dart

 // Copyright (c) 2014, 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.
 
 /// A Shelf adapter for handling [HttpRequest] objects from `dart:io`.
 ///
 /// One can provide an instance of [HttpServer] as the `requests` parameter in
 /// [serveRequests].
 ///
 /// The `dart:io` adapter supports request hijacking; see [Request.hijack].
@@ skipping 34 matching lines @@
   catchTopLevelErrors(() {
     requests.listen((request) => handleRequest(request, handler));
   }, (error, stackTrace) {
     _logError('Asynchronous error\n$error', stackTrace);
   });
 }
 
 /// Uses [handler] to handle [request].
 ///
 /// Returns a [Future] which completes when the request has been handled.
-Future handleRequest(HttpRequest request, Handler handler) {
+///
+/// If [includeDateHeader] is `true`, the `Date` header is included with a value
+/// of `new DateTime.now` at the time the response is written. The default is
+/// `true`.

[nweiz, 2014/05/27 19:52:44]

Why is this configurable? Any configuration that's included in shelf_io runs the
risk of becoming standard for all adapters, which increases the barrier to entry
of writing a new adapter.

I don't think we should make this configurable without a clear use case for
configuring it.

[kevmoo, 2014/05/27 20:50:58]

DONE

I guess we can always add this later if demand arises.

+Future handleRequest(HttpRequest request, Handler handler,
+    {bool includeDateHeader: true}) {
   var shelfRequest = _fromHttpRequest(request);
 
   // TODO(nweiz): abstract out hijack handling to make it easier to implement an
   // adapter.
   return syncFuture(() => handler(shelfRequest))
       .catchError((error, stackTrace) {
     if (error is HijackException) {
       // A HijackException should bypass the response-writing logic entirely.
       if (!shelfRequest.canHijack) throw error;
 
@@ skipping 10 matching lines @@
     } else if (!shelfRequest.canHijack) {
       var message = new StringBuffer()
           ..writeln("Got a response for hijacked request "
               "${shelfRequest.method} ${shelfRequest.requestedUri}:")
           ..writeln(response.statusCode);
       response.headers.forEach((key, value) =>
           message.writeln("${key}: ${value}"));
       throw new Exception(message.toString().trim());
     }
 
-    return _writeResponse(response, request.response);
+    return _writeResponse(response, request.response, includeDateHeader);
   }).catchError((error, stackTrace) {
     // Ignore HijackExceptions.
     if (error is! HijackException) throw error;
   });
 }
 
 /// Creates a new [Request] from the provided [HttpRequest].
 Request _fromHttpRequest(HttpRequest request) {
   var headers = {};
   request.headers.forEach((k, v) {
     // Multiple header values are joined with commas.
     // See http://tools.ietf.org/html/draft-ietf-httpbis-p1-messaging-21#page-22
     headers[k] = v.join(',');
   });
 
   onHijack(callback) {
     return request.response.detachSocket(writeHeaders: false)
         .then((socket) => callback(socket, socket));
   }
 
   return new Request(request.method, request.requestedUri,
       protocolVersion: request.protocolVersion, headers: headers,
       body: request, onHijack: onHijack);
 }
 
-Future _writeResponse(Response response, HttpResponse httpResponse) {
+Future _writeResponse(Response response, HttpResponse httpResponse,
+    bool includeDateHeader) {
   httpResponse.statusCode = response.statusCode;
 
   response.headers.forEach((header, value) {
     if (value == null) return;
     httpResponse.headers.set(header, value);
   });
 
   if (response.headers[HttpHeaders.SERVER] == null) {
     var value = httpResponse.headers.value(HttpHeaders.SERVER);
     httpResponse.headers.set(HttpHeaders.SERVER, '$value with Shelf');
   }
+
+  if (includeDateHeader && !response.headers.containsKey(HttpHeaders.DATE)) {
+    httpResponse.headers.date = new DateTime.now().toUtc();
+  }
+
   return httpResponse.addStream(response.read())
       .then((_) => httpResponse.close());
 }
 
 // TODO(kevmoo) A developer mode is needed to include error info in response
 // TODO(kevmoo) Make error output plugable. stderr, logging, etc
 Response _logError(String message, [StackTrace stackTrace]) {
   var chain = new Chain.current();
   if (stackTrace != null) {
     chain = new Chain.forTrace(stackTrace);
   }
   chain = chain
       .foldFrames((frame) => frame.isCore || frame.package == 'shelf')
       .terse;
 
   stderr.writeln('ERROR - ${new DateTime.now()}');
   stderr.writeln(message);
   stderr.writeln(chain);
   return new Response.internalServerError();
 }