Provide and respect HTTP cache headers in pub serve.

lib/src/barback/barback_server.dart

 // Copyright (c) 2013, 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.
 
 import 'dart:async';
+import 'dart:convert';
 import 'dart:io';
 
 import 'package:barback/barback.dart';
+import "package:crypto/crypto.dart";
 import 'package:mime/mime.dart';
 import 'package:path/path.dart' as path;
 import 'package:shelf/shelf.dart' as shelf;
 import 'package:stack_trace/stack_trace.dart';
 
 import '../barback.dart';
 import '../io.dart';
 import '../log.dart' as log;
 import '../utils.dart';
 import 'base_server.dart';
@@ skipping 63 matching lines @@
     var parts = path.url.split(url.path);
 
     // Strip the leading "/" from the URL.
     if (parts.isNotEmpty && parts.first == "/") parts = parts.skip(1);
 
     var relativePath = path.url.join(rootDirectory, path.url.joinAll(parts));
     return new AssetId(package, relativePath);
   }
 
   /// Handles an HTTP request.
-  handleRequest(shelf.Request request) {
+  Future<shelf.Response> handleRequest(shelf.Request request) async {
     if (request.method != "GET" && request.method != "HEAD") {
       return methodNotAllowed(request);
     }
 
     var id;
     try {
       id = urlToId(request.url);
     } on FormatException catch (ex) {
       // If we got here, we had a path like "/packages" which is a special
       // directory, but not a valid path since it lacks a following package
@@ skipping 44 matching lines @@
       // Allow requests of any origin to access "pub serve". This is useful for
       // running "pub serve" in parallel with another development server. Since
       // "pub serve" is only used as a development server and doesn't require
       // any sort of credentials anyway, this is secure.
       return response.change(
           headers: const {"Access-Control-Allow-Origin": "*"});
     });
   }
 
   /// Returns the body of [asset] as a response to [request].
-  Future<shelf.Response> _serveAsset(shelf.Request request, Asset asset) {
-    return validateStream(asset.read()).then((stream) {
-      addResult(new BarbackServerResult._success(request.url, asset.id));
-      var headers = {};
-      var mimeType = lookupMimeType(asset.id.path);
-      if (mimeType != null) headers['Content-Type'] = mimeType;
-      return new shelf.Response.ok(stream, headers: headers);
-    }).catchError((error, trace) {
+  Future<shelf.Response> _serveAsset(shelf.Request request, Asset asset) async {
+    try {
+      var pair = tee(await validateStream(asset.read()));
+      var responseStream = pair.first;
+      var hashStream = pair.last;
+
+      // Allow the asset to be cached based on its content hash.
+      var sha = new SHA1();
+      await hashStream.forEach((chunk) {
+        sha.add(chunk);
+      });
+
+      var assetSha = BASE64.encode(sha.close());
+      var previousSha = request.headers["if-none-match"];
+
+      var headers = {
+        // Enabled browser caching of the asset.
+        "Cache-Control": "max-age=3600",
+        "ETag": assetSha
+      };
+
+      if (assetSha == previousSha) {
+        // We're requesting an unchanged asset so don't push its body down the
+        // wire again.
+        addResult(new BarbackServerResult._cached(request.url, asset.id));
+        return new shelf.Response.notModified(headers: headers);
+      } else {
+        addResult(new BarbackServerResult._success(request.url, asset.id));
+        var mimeType = lookupMimeType(asset.id.path);
+        if (mimeType != null) headers['Content-Type'] = mimeType;
+        return new shelf.Response.ok(responseStream, headers: headers);
+      }
+    } catch (error, trace) {
       addResult(new BarbackServerResult._failure(request.url, asset.id, error));
 
       // If we couldn't read the asset, handle the error gracefully.
       if (error is FileSystemException) {
         // Assume this means the asset was a file-backed source asset
         // and we couldn't read it, so treat it like a missing asset.
         return notFound(request, error: error.toString(), asset: asset.id);
       }
 
       trace = new Chain.forTrace(trace);
       logRequest(request, "$error\n$trace");
 
       // Otherwise, it's some internal error.
       return new shelf.Response.internalServerError(body: error.toString());
-    });
+    }
   }
 }
 
 /// The result of the server handling a URL.
 ///
 /// Only requests for which an asset was requested from barback will emit a
 /// result. Malformed requests will be handled internally.
 class BarbackServerResult {
   /// The requested url.
   final Uri url;
 
   /// The id that [url] identifies.
   final AssetId id;
 
   /// The error thrown by barback.
   ///
   /// If the request was served successfully, this will be null.
   final error;
 
   /// Whether the request was served successfully.
   bool get isSuccess => error == null;
 
+  /// Whether the request was for a previously cached asset.
+  final bool isCached;
+
   /// Whether the request was served unsuccessfully.
   bool get isFailure => !isSuccess;
 
   BarbackServerResult._success(this.url, this.id)
-      : error = null;
+      : error = null,
+        isCached = false;
 
-  BarbackServerResult._failure(this.url, this.id, this.error);
+  BarbackServerResult._cached(this.url, this.id)
+      : error = null,
+        isCached = true;
+
+  BarbackServerResult._failure(this.url, this.id, this.error)
+      : isCached = false;
 }