Test server tweaks

tools/testing/dart/http_server.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.
 
 library http_server;
 
 import 'dart:io';
 import 'dart:isolate';
 import 'test_suite.dart';  // For TestUtils.
 // TODO(efortuna): Rewrite to not use the args library and simply take an
@@ skipping 10 matching lines @@
   parser.addOption('crossOriginPort', abbr: 'c',
       help: 'A different port that accepts request from the main server port.',
       defaultsTo: '0');
   parser.addOption('mode', abbr: 'm', help: 'Testing mode.',
       defaultsTo: 'release');
   parser.addOption('arch', abbr: 'a', help: 'Testing architecture.',
       defaultsTo: 'ia32');
   parser.addFlag('help', abbr: 'h', negatable: false,
       help: 'Print this usage information.');
   parser.addOption('package-root', help: 'The package root to use.');
+  parser.addOption('network', help: 'The network interface to use.',
+      defaultsTo: '127.0.0.1');
   var args = parser.parse(new Options().arguments);
   if (args['help']) {
     print(parser.getUsage());
   } else {
     // Pretend we're running test.dart so that TestUtils doesn't get confused
     // about the "current directory." This is only used if we're trying to run
     // this file independently for local testing.
     TestUtils.testScriptPath = new Path(new Options().script)
         .directoryPath
         .join(new Path('../../test.dart'))
         .canonicalize()
         .toNativePath();
     // Note: args['package-root'] is always the build directory. We have the
     // implicit assumption that it contains the 'packages' subdirectory.
     // TODO: We should probably rename 'package-root' to 'build-directory'.
     TestingServerRunner._packageRootDir = new Path(args['package-root']);
     TestingServerRunner._buildDirectory = new Path(args['package-root']);
-    TestingServerRunner.startHttpServer('127.0.0.1',
+    var network = args['network'];
+    TestingServerRunner.startHttpServer(network,
         port: int.parse(args['port']));
     print('Server listening on port '
           '${TestingServerRunner.serverList[0].port}.');
-    TestingServerRunner.startHttpServer('127.0.0.1',
+    TestingServerRunner.startHttpServer(network,
         allowedPort: TestingServerRunner.serverList[0].port, port:
         int.parse(args['crossOriginPort']));
     print(
         'Server listening on port ${TestingServerRunner.serverList[1].port}.');
   }
 }
 /**
  * Runs a set of servers that are initialized specifically for the needs of our
  * test framework, such as dealing with package-root.
  */
@@ skipping 48 matching lines @@
         var requestPathStr = requestPath.toNativePath().substring(
             requestPath.toNativePath().indexOf(packagesDirName));
         path = packageRootDir.append(requestPathStr);
         file = new File(path.toNativePath());
       }
       file.exists().then((exists) {
         if (exists) {
           if (allowedPort != -1) {
             // Allow loading from localhost:$allowedPort in browsers.
             resp.headers.set("Access-Control-Allow-Origin",
-                "http://127.0.0.1:$allowedPort");
+                request.headers['Origin']);

[kustermann, 2013/02/12 19:00:48]

I'm not so familiar with cross-domain requests, but here's the way I understand
it:

Previously we said:
  - If a website loaded from '127.0.0.1:$allowedPort' want's to access content
on this server, we allow it.

With your change: 
  - No matter from where the request comes from (it's stored in
request.headers['Origin']): we allow access to content on this server.

I'm not sure if we want this behavior: If we want to test the case where access
is denied your modification breaks things.

[blois, 2013/02/12 20:31:12]

Updated to use the hostname from the origin but to allow only the allowed port.

             resp.headers.set('Access-Control-Allow-Credentials', 'true');
           } else {
             // No allowedPort specified. Allow from anywhere (but cross-origin
             // requests *with credentials* will fail because you can't use "*").
             resp.headers.set("Access-Control-Allow-Origin", "*");
           }
           if (path.toNativePath().endsWith('.html')) {
             resp.headers.set('Content-Type', 'text/html');
           } else if (path.toNativePath().endsWith('.js')) {
             resp.headers.set('Content-Type', 'application/javascript');
           } else if (path.toNativePath().endsWith('.dart')) {
             resp.headers.set('Content-Type', 'application/dart');
           }
           file.openInputStream().pipe(resp.outputStream);
         } else {
-          resp.statusCode = HttpStatus.NOT_FOUND;
-          try {
-            resp.outputStream.close();
-          } catch (e) {
-            if (e is StreamException) {
-              print('Test http_server error closing the response stream: $e');
+          var directory = new Directory(path.toNativePath());

[kustermann, 2013/02/12 19:00:48]

Since there is a 'new Directory.fromPath()' we should actually use it!

[blois, 2013/02/12 20:31:12]

Done.

+          directory.exists().then((exists) {
+            if (!exists) {
+              sendNotFound(resp);
             } else {
-              throw e;
+              sendDirectoryListing(directory, request, resp);
             }
-          }
+          });
         }
       });
     };
 
     // Echos back the contents of the request as the response data.
     httpServer.addRequestHandler((req) => req.path == "/echo", (request, resp) {
       resp.headers.set("Access-Control-Allow-Origin", "*");
 
       request.inputStream.pipe(resp.outputStream);
     });
 
     httpServer.listen(host, port);
     serverList.add(httpServer);
   }
 
+  static void sendNotFound(HttpResponse response) {
+    response.statusCode = HttpStatus.NOT_FOUND;
+    try {
+      response.outputStream.close();
+    } catch (e) {
+      if (e is StreamException) {
+        print('Test http_server error closing the response stream: $e');
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  static void sendDirectoryListing(Directory directory, HttpRequest request,
+      HttpResponse response) {
+    var os = response.outputStream;
+
+    var header = '''<!DOCTYPE html>
+    <html>
+    <head>
+      <title>${request.path}</title>
+    </head>
+    <body>
+      <code>
+        <div>${request.path}</div>
+        <hr/>
+        <ul>''';
+    var footer = '''
+        </ul>
+      </code>
+    </body>
+    </html>''';
+
+    os.writeString(header);
+
+    var files = [];
+
+    directory.list()
+      ..onFile = (filepath) {
+        files.add(filepath);
+      }
+      ..onDir = (dirpath) {
+        files.add('$dirpath/');

[kustermann, 2013/02/12 19:00:48]

AFAIK, this results in an entry in files with forward AND backward slashes on
windows!

[blois, 2013/02/12 20:31:12]

Cleaned this up some- it's a bit odd as the '/' was essentially a sentinel that
this was a directory and I was attempting to cram everything into a single
value.

+      }
+      ..onDone = (_) {
+        files.sort();
+        for (var file in files) {
+          var filename = new Path.raw(file).filename;

[kustermann, 2013/02/12 19:00:48]

DirectoryLister gives AFAIK full native paths. So you should use 'new
Path(file)' here!

[blois, 2013/02/12 20:31:12]

Done.

+          // no filename implies directory name.
+          if (filename.isEmpty) {
+            var dirname = new Path.raw(file).directoryPath.filename;

[kustermann, 2013/02/12 19:00:48]

Same here.

[blois, 2013/02/12 20:31:12]

Done.

+            filename = '$dirname/';
+          }
+          os.writeString(
+              '<li><a href="${request.path}$filename">$filename</a></li>');

[kustermann, 2013/02/12 19:00:48]

I think you implicitly assume that '${request.path}' ends with a slash. You
should make sure that there is a slash (and append one otherwise).

[blois, 2013/02/12 20:31:12]

Yeah, and assuming that there is a trailing slash was making the filepath
handling odd as well.

+        }
+        os.writeString(footer);
+        os.close();
+      };
+  }
+
   static terminateHttpServers() {
     for (var server in serverList) server.close();
   }
 }