Add support for IfModifiedSince headers, in http_servers' VirtualDirectory.

pkg/http_server/lib/src/virtual_directory.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.
 
 part of http_server;
 
 /**
  * A [VirtualDirectory] can serve files and directory-listing from a root path,
  * to [HttpRequest]s.
  *
@@ skipping 60 matching lines @@
       return _serveErrorPage(HttpStatus.NOT_FOUND, request);
     }
 
     _locateResource(new Path(root), path.segments())
         .then((entity) {
           if (entity == null) {
             _serveErrorPage(HttpStatus.NOT_FOUND, request);
             return;
           }
           if (entity is File) {
-            entity.openRead().pipe(request.response).catchError((_) {});
+            _serveFile(entity, request);
           } else {
             _serveErrorPage(HttpStatus.NOT_FOUND, request);
           }
         });
   }
 
   Future<FileSystemEntity> _locateResource(Path path,
                                            Iterable<String> segments) {
     return FileSystemEntity.type(path.toNativePath(), followLinks: false)
         .then((type) {
@@ skipping 15 matching lines @@
               if (followLinks) {
                 // TODO
               }
               break;
           }
           // Return `null` on fall-through, to indicate NOT_FOUND.
           return null;
         });
   }
 
+  void _serveFile(File file, HttpRequest request) {
+    file.lastModified().then((lastModified) {
+      var response = request.response;
+
+      if (request.headers.ifModifiedSince != null &&
+          !lastModified.isAfter(request.headers.ifModifiedSince)) {
+        response.statusCode = HttpStatus.NOT_MODIFIED;
+        response.close();
+        return;
+      }
+
+      response.headers.set(HttpHeaders.LAST_MODIFIED, lastModified);
+      response.headers.set(HttpHeaders.ACCEPT_RANGES, "bytes");
+
+      if (request.method == 'HEAD') {
+        response.close();
+        return;
+      }
+
+      file.length().then((length) {
+        String range = request.headers.value("range");
+        if (range != null) {
+          // We only support one range, where the standard support several.
+          Match matches = new RegExp(r"^bytes=(\d*)\-(\d*)$").firstMatch(range);
+          // If the range header have the right format, handle it.
+          if (matches != null) {
+            // Serve sub-range.
+            int start;
+            int end;
+            if (matches[1].isEmpty) {
+              start = matches[2].isEmpty ?
+                  length :
+                  length - int.parse(matches[2]);
+              end = length;
+            } else {
+              start = int.parse(matches[1]);
+              end = matches[2].isEmpty ? length : int.parse(matches[2]) + 1;
+            }
+
+            // Override Content-Length with the actual bytes sent.
+            response.headers.set(HttpHeaders.CONTENT_LENGTH, end - start);
+
+            // Set 'Partial Content' status code.
+            response.statusCode = HttpStatus.PARTIAL_CONTENT;
+            response.headers.set(HttpHeaders.CONTENT_RANGE,
+                                 "bytes $start-${end - 1}/$length");
+
+            // Pipe the 'range' of the file.
+            file.openRead(start, end).pipe(response).catchError((_) {});
+            return;
+          }
+        }
+
+        file.openRead().pipe(response).catchError((_) {});

[Søren Gjesse, 2013/06/24 08:17:24]

I don't think we should just swallow all errors. We should make this work well
with the zone error handling.

You can add a TODO for now.

+      }, onError: (_) {});
+    }, onError: (_) {});
+  }
+
   void _serveErrorPage(int error, HttpRequest request) {
     request.response.statusCode = error;
     request.response.close();
   }
 }