Start two http servers for every configuration

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:async';
 import 'dart:io';
 import 'dart:isolate';
 import 'dart:uri';
@@ skipping 19 matching lines @@
 /// In case a path does not refer to a file but rather to a directory, a
 /// directory listing will be displayed.
 
 const PREFIX_BUILDDIR = 'root_build';
 const PREFIX_DARTDIR = 'root_dart';
 
 // TODO(kustermann,ricow): We could change this to the following scheme:
 // http://host:port/root_packages/X -> $BuildDir/packages/X
 // Issue: 8368
 
-
 main() {
   /** Convenience method for local testing. */
   var parser = new ArgParser();
   parser.addOption('port', abbr: 'p',
       help: 'The main server port we wish to respond to requests.',
       defaultsTo: '0');
   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('build-directory', help: 'The package root to use.');

[ricow1, 2013/02/25 11:42:56]

Update option help text

[kustermann, 2013/02/25 11:51:22]

Done.

   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']);
-    var network = args['network'];
-    TestingServerRunner.startHttpServer(network,
-        port: int.parse(args['port']));
-    print('Server listening on port '
-          '${TestingServerRunner.serverList[0].port}.');
-    TestingServerRunner.startHttpServer(network,
-        allowedPort: TestingServerRunner.serverList[0].port, port:
-        int.parse(args['crossOriginPort']));
-    print(
-        'Server listening on port ${TestingServerRunner.serverList[1].port}.');
+    var servers = new TestingServers(new Path(args['build-directory']));
+    var port = int.parse(args['port']);
+    var crossOriginPort = int.parse(args['crossOriginPort']);
+    servers.startServers(args['network'],
+                         port: port,
+                         crossOriginPort: crossOriginPort);
+    DebugLogger.info('Server listening on port ${servers.port}');
+    DebugLogger.info('Server listening on port ${servers.crossOriginPort}');
   }
 }
+
 /**
  * Runs a set of servers that are initialized specifically for the needs of our
  * test framework, such as dealing with package-root.
  */
-class TestingServerRunner {
-  static List serverList = [];
-  static Path _packageRootDir = null;
-  static Path _buildDirectory = null;
+class TestingServers {
+  List _serverList = [];
+  Path _buildDirectory = null;
 
-  // Added as a getter so that the function will be called again each time the
-  // default request handler closure is executed.
-  static Path get packageRootDir => _packageRootDir;
-  static Path get buildDirectory => _buildDirectory;
-
-  static setPackageRootDir(Map configuration) {
-    _packageRootDir = TestUtils.absolutePath(
-        new Path(TestUtils.buildDir(configuration)));
+  TestingServers(Path buildDirectory) {
+    _buildDirectory = TestUtils.absolutePath(buildDirectory);
   }
 
-  static setBuildDir(Map configuration) {
-    _buildDirectory = TestUtils.absolutePath(
-        new Path(TestUtils.buildDir(configuration)));
+  int get port => _serverList[0].port;
+  int get crossOriginPort => _serverList[1].port;
+
+  /**
+   * [startHttpServer] will start two Http servers.

[ricow1, 2013/02/25 11:42:56]

startHttpServer -> startServers

[kustermann, 2013/02/25 11:51:22]

Done.

+   * The first server listens on [port] and sets
+   *   "Access-Control-Allow-Origin: *"
+   * The second server listens on [crossOriginPort] and sets
+   *   "Access-Control-Allow-Origin: client:port1
+   *   "Access-Control-Allow-Credentials: true"
+   */
+  void startServers(String host, {int port: 0, int crossOriginPort: 0}) {
+    _startHttpServer(host, port: port);
+    _startHttpServer(host,
+                     port: crossOriginPort,
+                     allowedPort:_serverList[0].port);
   }
 
-  static startHttpServer(String host, {int allowedPort:-1, int port: 0}) {
+  String httpServerCommandline() {
+    var dart = TestUtils.dartTestExecutable.toNativePath();
+    var dartDir = TestUtils.dartDir();
+    var script = dartDir.join(new Path("tools/testing/dart/http_server.dart"));
+    var buildDirectory = _buildDirectory.toNativePath();
+
+    return '$dart $script -p $port -c $crossOriginPort '
+           '--build-directory=$buildDirectory';
+  }
+
+  void stopServers() {
+    for (var server in _serverList) {
+      server.close();
+    }
+  }
+
+  void _startHttpServer(String host, {int port: 0, int allowedPort: -1}) {
     var httpServer = new HttpServer();
     httpServer.onError = (e) {
       DebugLogger.error('HttpServer: an error occured: $e');
     };
     httpServer.defaultRequestHandler = (request, response) {
-      handleFileOrDirectoryRequest(request, response, allowedPort);
+      _handleFileOrDirectoryRequest(request, response, allowedPort);
     };
     httpServer.addRequestHandler(
-        (req) => req.path == "/echo", handleEchoRequest);
+        (req) => req.path == "/echo", _handleEchoRequest);
 
     httpServer.listen(host, port);
-    serverList.add(httpServer);
+    _serverList.add(httpServer);
   }
 
-
-  static void handleFileOrDirectoryRequest(HttpRequest request,
-                                           HttpResponse response,
-                                           int allowedPort) {
-    var path = getFilePathFromRequestPath(request.path);
+  void _handleFileOrDirectoryRequest(HttpRequest request,
+                                     HttpResponse response,
+                                     int allowedPort) {
+    var path = _getFilePathFromRequestPath(request.path);
     if (path != null) {
       var file = new File.fromPath(path);
       file.exists().then((exists) {
         if (exists) {
-          sendFileContent(request, response, allowedPort, path, file);
+          _sendFileContent(request, response, allowedPort, path, file);
         } else {
           var directory = new Directory.fromPath(path);
           directory.exists().then((exists) {
             if (exists) {
-              listDirectory(directory).then((entries) {
-                sendDirectoryListing(entries, request, response);
+              _listDirectory(directory).then((entries) {
+                _sendDirectoryListing(entries, request, response);
               });
             } else {
-              sendNotFound(request, response);
+              _sendNotFound(request, response);
             }
           });
         }
       });
     } else {
       if (request.path == '/') {
         var entries = [new _Entry('root_dart', 'root_dart/'),
                        new _Entry('root_build', 'root_build/'),
                        new _Entry('echo', 'echo')];
-        sendDirectoryListing(entries, request, response);
+        _sendDirectoryListing(entries, request, response);
       } else {
-        sendNotFound(request, response);
+        _sendNotFound(request, response);
       }
     }
   }
 
-  static void handleEchoRequest(HttpRequest request, HttpResponse response) {
+  void _handleEchoRequest(HttpRequest request, HttpResponse response) {
     response.headers.set("Access-Control-Allow-Origin", "*");
     request.inputStream.pipe(response.outputStream);
   }
 
-  static Path getFilePathFromRequestPath(String urlRequestPath) {
+  Path _getFilePathFromRequestPath(String urlRequestPath) {
     // Go to the top of the file to see an explanation of the URL path scheme.
     var requestPath = new Path(urlRequestPath.substring(1)).canonicalize();
     var pathSegments = requestPath.segments();
     if (pathSegments.length > 0) {
       var basePath;
       var relativePath;
       if (pathSegments[0] == PREFIX_BUILDDIR) {
         basePath = _buildDirectory;
         relativePath = new Path(
             pathSegments.getRange(1, pathSegments.length - 1).join('/'));
       } else if (pathSegments[0] == PREFIX_DARTDIR) {
         basePath = TestUtils.dartDir();
         relativePath = new Path(
             pathSegments.getRange(1, pathSegments.length - 1).join('/'));
       }
       var packagesDirName = 'packages';
       var packagesIndex = pathSegments.indexOf(packagesDirName);
       if (packagesIndex != -1) {
         var start = packagesIndex + 1;
         var length = pathSegments.length - start;
-        basePath = _packageRootDir.append(packagesDirName);
+        basePath = _buildDirectory.append(packagesDirName);
         relativePath = new Path(
             pathSegments.getRange(start, length).join('/'));
       }
       if (basePath != null && relativePath != null) {
         return basePath.join(relativePath);
       }
     }
     return null;
   }
 
-  static Future<List<_Entry>> listDirectory(Directory directory) {
+  Future<List<_Entry>> _listDirectory(Directory directory) {
     var completer = new Completer();
     var entries = [];
 
     directory.list()
       ..onFile = (filepath) {
         var filename = new Path(filepath).filename;
         entries.add(new _Entry(filename, filename));
       }
       ..onDir = (dirpath) {
         var filename = new Path(dirpath).filename;
         entries.add(new _Entry(filename, '$filename/'));
       }
       ..onDone = (_) {
         completer.complete(entries);
       };
     return completer.future;
   }
 
-  /**
-   * Sends a simple listing of all the files and sub-directories within
-   * directory.
-   *
-   * This is intended to make it easier to browse tests when manually running
-   * tests against this test server.
-   */
-  static void sendDirectoryListing(entries,
-                                   HttpRequest request,
-                                   HttpResponse response) {
+  void _sendDirectoryListing(List<_Entry> entries,
+                             HttpRequest request,
+                             HttpResponse response) {
     response.headers.set('Content-Type', 'text/html');
     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>''';
 
 
     entries.sort();
     response.outputStream.writeString(header);
     for (var entry in entries) {
       response.outputStream.writeString(
           '<li><a href="${new Path(request.path).append(entry.name)}">'
           '${entry.displayName}</a></li>');
     }
     response.outputStream.writeString(footer);
     response.outputStream.close();
   }
 
-  static void sendFileContent(HttpRequest request,
-                              HttpResponse response,
-                              int allowedPort,
-                              Path path,
-                              File file) {
+  void _sendFileContent(HttpRequest request,
+                        HttpResponse response,
+                        int allowedPort,
+                        Path path,
+                        File file) {
     if (allowedPort != -1) {
       var origin = new Uri(request.headers.value('Origin'));
       // Allow loading from http://*:$allowedPort in browsers.
       var allowedOrigin =
           '${origin.scheme}://${origin.domain}:${allowedPort}';
       response.headers.set("Access-Control-Allow-Origin", allowedOrigin);
       response.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 "*").
       response.headers.set("Access-Control-Allow-Origin", "*");
     }
     if (path.filename.endsWith('.html')) {
       response.headers.set('Content-Type', 'text/html');
     } else if (path.filename.endsWith('.js')) {
       response.headers.set('Content-Type', 'application/javascript');
     } else if (path.filename.endsWith('.dart')) {
       response.headers.set('Content-Type', 'application/dart');
     }
     file.openInputStream().pipe(response.outputStream);
   }
 
-  static void sendNotFound(HttpRequest request, HttpResponse response) {
+  void _sendNotFound(HttpRequest request, HttpResponse response) {
     // NOTE: Since some tests deliberately try to access non-existent files.
     // We might want to remove this warning (otherwise it will show
     // up in the debug.log every time).
     DebugLogger.warning('HttpServer: could not find file for request path: '
                         '"${request.path}"');
     response.statusCode = HttpStatus.NOT_FOUND;
     try {
       response.outputStream.close();
     } catch (e) {
       if (e is StreamException) {
         DebugLogger.warning('HttpServer: error while closing the response '
                             'stream: $e');
       } else {
         throw e;
       }
     }
   }
-
-  static terminateHttpServers() {
-    for (var server in serverList) server.close();
-  }
 }
 
 // Helper class for displaying directory listings.
 class _Entry {
   final String name;
   final String displayName;
 
   _Entry(this.name, this.displayName);
 
   int compareTo(_Entry other) {
     return name.compareTo(other.name);
   }
 }