appengine: throw AssetErrors directly (instead of via new Future.error

lib/src/server/assets.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.
 
 library appengine.assets;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:http_server/http_server.dart' show VirtualDirectory;
@@ skipping 29 matching lines @@
           proxyResponse.headers.forEach((name, values) {
             if (RESPONSE_HEADERS.contains(name)) {
               request.response.headers.set(name, values);
             }
           });
           request.response.statusCode = proxyResponse.statusCode;
           request.response.reasonPhrase = proxyResponse.reasonPhrase;
           return proxyResponse.pipe(request.response);
         })
         .catchError((e) {
           print("Unable to connect to 'pub serve' for '${request.uri}': $e");

[kevmoo, 2014/11/10 21:57:56]

Should we get rid of this print statement, too? Or move it to logging?

[kustermann, 2014/11/11 09:53:13]

"stdout" is currently our log for locally testing. Log messages here might not
be written with the logging service because the request is already done (see the
.pipe() above).

It's a nasty artifiact, that we can fix once we switch to the new way of doing
logging.

Please add a TODO here to use the logging service.

[kevmoo, 2014/11/11 15:15:52]

Done.

-          var error = new AssetError(
+          throw new AssetError(
               "Unable to connect to 'pub serve' for '${request.uri}': $e");
-          return new Future.error(error);
         });
   }
 
   Future _serveFromFile(HttpRequest request, String path) {
     // Check if the request path is pointing to a static resource.
     path = normalize(path);
     return FileSystemEntity.isFile(root + path).then((exists) {
       if (exists) {
         return vd.serveFile(new File(root + path), request);
       } else {
         return _serve404(request);
       }
     });
   }
 
   Future<Stream<List<int>>> _readFromPub(String path) {
     var uri = pubServeUrl.resolve(path);
     return client.openUrl('GET', uri)
         .then((request) => request.close())
         .then((response) {
           if (response.statusCode == HttpStatus.OK) {
             return response;
           } else {
-            var error = new AssetError(
+            throw new AssetError(
                 "Failed to fetch asset '$path' from pub: "
                 "${response.statusCode}.");
-            return new Future.error(error);
           }
         })
         .catchError((error) {
           if (error is! AssetError) {
             error = new AssetError(
                 "Failed to fetch asset '$path' from pub: '${path}': $error");
           }
-          return new Future.error(error);
+          throw error;
         });
   }
 
   Future<Stream<List<int>>> _readFromFile(String path) {
     path = normalize(path);
     return FileSystemEntity.isFile(root + path).then((exists) {
       if (exists) {
         return new File(root + path).openRead();
       } else {
-        var error = new AssetError("Asset '$path' not found");
-        return new Future.error(error);
+        throw new AssetError("Asset '$path' not found");
       }
     });
   }
 
   Future _serve404(HttpRequest request) {
     // Serve 404.
     return request.drain().then((_) {
       return request.response
           ..statusCode = HttpStatus.NOT_FOUND
           ..close();
@@ skipping 26 matching lines @@
   Future<Stream<List<int>>> read([String path]) {
     return appengineContext.assets.read(
         path == null ? request.uri.path : path);
   }
 
   void serve([String path]) {
     appengineContext.assets.serve(request,
         path == null ? request.uri.path : path);
   }
 }