| // 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'; |
| import 'test_suite.dart'; // For TestUtils. |
| // TODO(efortuna): Rewrite to not use the args library and simply take an |
| // expected number of arguments, so test.dart doesn't rely on the args library? |
| // See discussion on https://codereview.chromium.org/11931025/. |
| import 'vendored_pkg/args/args.dart'; |
| import 'utils.dart'; |
| |
| |
| /// Interface of the HTTP server: |
| /// |
| /// /echo: This will stream the data received in the request stream back |
| /// to the client. |
| /// /root_dart/X: This will serve the corresponding file from the dart |
| /// directory (i.e. '$DartDirectory/X'). |
| /// /root_build/X: This will serve the corresponding file from the build |
| /// directory (i.e. '$BuildDirectory/X'). |
| /// /FOO/packages/BAR: This will serve the corresponding file from the packages |
| /// directory (i.e. '$BuildDirectory/packages/BAR') |
| /// |
| /// 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('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}.'); |
| } |
| } |
| /** |
| * 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; |
| |
| // 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))); |
| } |
| |
| static setBuildDir(Map configuration) { |
| _buildDirectory = TestUtils.absolutePath( |
| new Path(TestUtils.buildDir(configuration))); |
| } |
| |
| static startHttpServer(String host, {int allowedPort:-1, int port: 0}) { |
| var httpServer = new HttpServer(); |
| httpServer.onError = (e) { |
| DebugLogger.error('HttpServer: an error occured: $e'); |
| }; |
| httpServer.defaultRequestHandler = (request, response) { |
| handleFileOrDirectoryRequest(request, response, allowedPort); |
| }; |
| httpServer.addRequestHandler( |
| (req) => req.path == "/echo", handleEchoRequest); |
| |
| httpServer.listen(host, port); |
| serverList.add(httpServer); |
| } |
| |
| |
| static 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); |
| } else { |
| var directory = new Directory.fromPath(path); |
| directory.exists().then((exists) { |
| if (exists) { |
| listDirectory(directory).then((entries) { |
| sendDirectoryListing(entries, request, response); |
| }); |
| } else { |
| 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); |
| } else { |
| sendNotFound(request, response); |
| } |
| } |
| } |
| |
| static void handleEchoRequest(HttpRequest request, HttpResponse response) { |
| response.headers.set("Access-Control-Allow-Origin", "*"); |
| request.inputStream.pipe(response.outputStream); |
| } |
| |
| static 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); |
| 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) { |
| 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) { |
| 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) { |
| 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) { |
| // 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); |
| } |
| } |