library angel_framework.http.server; import 'dart:async'; import 'dart:io'; import 'dart:math' show Random; import 'dart:mirrors'; import 'package:json_god/json_god.dart' as god; import 'angel_base.dart'; import 'angel_http_exception.dart'; import 'controller.dart'; import 'request_context.dart'; import 'response_context.dart'; import 'routable.dart'; import 'route.dart'; import 'service.dart'; export 'package:container/container.dart'; /// A function that binds an [Angel] server to an Internet address and port. typedef Future ServerGenerator(InternetAddress address, int port); /// Handles an [AngelHttpException]. typedef Future AngelErrorHandler( AngelHttpException err, RequestContext req, ResponseContext res); /// A function that configures an [AngelBase] server in some way. typedef Future AngelConfigurer(AngelBase app); /// A powerful real-time/REST/MVC server class. class Angel extends AngelBase { var _afterProcessed = new StreamController.broadcast(); var _beforeProcessed = new StreamController.broadcast(); var _fatalErrorStream = new StreamController.broadcast(); var _onController = new StreamController.broadcast(); ServerGenerator _serverGenerator = (address, port) async => await HttpServer.bind(address, port); /// Fired after a request is processed. Always runs. Stream get afterProcessed => _afterProcessed.stream; /// Fired before a request is processed. Always runs. Stream get beforeProcessed => _beforeProcessed.stream; /// Fired on fatal errors. Stream get fatalErrorStream => _fatalErrorStream.stream; /// Fired whenever a controller is added to this instance. /// /// **NOTE**: This is a broadcast stream. Stream get onController => _onController.stream; /// Default error handler, show HTML error page AngelErrorHandler _errorHandler = (AngelHttpException e, req, ResponseContext res) { res.header(HttpHeaders.CONTENT_TYPE, ContentType.HTML.toString()); res.status(e.statusCode); res.write("${e.message}"); res.write("

${e.message}

$error

"); res.end(); }; /// The handler currently configured to run on [AngelHttpException]s. AngelErrorHandler get errorHandler => _errorHandler; /// [RequestMiddleware] to be run before all requests. List before = []; /// [RequestMiddleware] to be run after all requests. List after = []; /// The native HttpServer running this instancce. HttpServer httpServer; /// Starts the server. /// /// Returns false on failure; otherwise, returns the HttpServer. Future startServer([InternetAddress address, int port]) async { var server = await _serverGenerator( address ?? InternetAddress.LOOPBACK_IP_V4, port ?? 0); this.httpServer = server; server.listen(handleRequest); return server; } /// Loads some base dependencies into the service container. void bootstrapContainer() { container.singleton(this, as: AngelBase); container.singleton(this); if (runtimeType != Angel) container.singleton(this, as: Angel); } Future handleRequest(HttpRequest request) async { _beforeProcessed.add(request); String requestedUrl = request.uri .toString() .replaceAll("?" + request.uri.query, "") .replaceAll(new RegExp(r'\/+$'), ''); if (requestedUrl.isEmpty) requestedUrl = '/'; RequestContext req = await RequestContext.from(request, {}, this, null); ResponseContext res = await ResponseContext.from(request.response, this); bool canContinue = true; executeHandler(handler, req) async { if (canContinue) { try { canContinue = await _applyHandler(handler, req, res); } catch (e, stackTrace) { if (e is AngelHttpException) { // Special handling for AngelHttpExceptions :) try { res.status(e.statusCode); String accept = request.headers.value(HttpHeaders.ACCEPT); if (accept == "*/*" || accept.contains(ContentType.JSON.mimeType) || accept.contains("application/javascript")) { res.json(e.toMap()); } else { await _errorHandler(e, req, res); } _finalizeResponse(request, res); } catch (_) {} } _onError(e, stackTrace); canContinue = false; return false; } } else return false; } for (var handler in before) { await executeHandler(handler, req); } for (Route route in routes) { if (!canContinue) break; if (route.matcher.hasMatch(requestedUrl) && (request.method == route.method || route.method == '*')) { req.params = route.parseParameters(requestedUrl); req.route = route; for (var handler in route.handlers) { await executeHandler(handler, req); } } } for (var handler in after) { await executeHandler(handler, req); } _finalizeResponse(request, res); } Future _applyHandler( handler, RequestContext req, ResponseContext res) async { if (handler is RequestMiddleware) { var result = await handler(req, res); if (result is bool) return result == true; else if (result != null) { res.json(result); return false; } else return res.isOpen; } if (handler is RequestHandler) { await handler(req, res); return res.isOpen; } if (handler is RawRequestHandler) { var result = await handler(req.underlyingRequest); if (result is bool) return result == true; else if (result != null) { res.json(result); return false; } else return true; } if (handler is Future) { var result = await handler; if (result is bool) return result == true; else if (result != null) { res.json(result); return false; } else return true; } if (handler is Function) { var result = await runContained(handler, req, res); if (result is bool) return result == true; else if (result != null) { res.json(result); return false; } else return true; } if (requestMiddleware.containsKey(handler)) { return await _applyHandler(requestMiddleware[handler], req, res); } res.willCloseItself = true; res.underlyingResponse.write(god.serialize(handler)); await res.underlyingResponse.close(); return false; } _finalizeResponse(HttpRequest request, ResponseContext res) async { try { _afterProcessed.add(request); if (!res.willCloseItself) { res.responseData.forEach((blob) => request.response.add(blob)); await request.response.close(); } } catch (e) { failSilently(request, res); } } String _randomString(int length) { var rand = new Random(); var codeUnits = new List.generate(length, (index) { return rand.nextInt(33) + 89; }); return new String.fromCharCodes(codeUnits); } // Run a function after injecting from service container Future runContained(Function handler, RequestContext req, ResponseContext res, {Map namedParameters, Map injecting}) async { ClosureMirror closureMirror = reflect(handler); List args = []; for (ParameterMirror parameter in closureMirror.function.parameters) { if (parameter.type.reflectedType == RequestContext) args.add(req); else if (parameter.type.reflectedType == ResponseContext) args.add(res); else { // First, search to see if we can map this to a type if (parameter.type.reflectedType != dynamic) { args.add(container.make(parameter.type.reflectedType, namedParameters: namedParameters, injecting: injecting)); } else { String name = MirrorSystem.getName(parameter.simpleName); if (req.params.containsKey(name)) args.add(req.params[name]); else if (name == "req") args.add(req); else if (name == "res") args.add(res); else { throw new Exception( "Cannot resolve parameter '$name' within handler."); } } } } return await closureMirror.apply(args).reflectee; } /// Applies an [AngelConfigurer] to this instance. Future configure(AngelConfigurer configurer) async { await configurer(this); if (configurer is Controller) _onController.add(configurer); } /// Fallback when an error is thrown while handling a request. void failSilently(HttpRequest request, ResponseContext res) {} /// Starts the server. void listen({InternetAddress address, int port: 3000}) { runZoned(() async { await startServer(address, port); }, onError: _onError); } @override use(Pattern path, Routable routable, {bool hooked: true, String middlewareNamespace: null}) { if (routable is Service) { routable.app = this; } return super.use(path, routable, hooked: hooked, middlewareNamespace: middlewareNamespace); } /// Registers a callback to run upon errors. onError(AngelErrorHandler handler) { _errorHandler = handler; } /// Handles a server error. _onError(e, [StackTrace stackTrace]) { _fatalErrorStream.add({ "error": e, "stack": stackTrace }); } Angel() : super() { bootstrapContainer(); } /// Creates an HTTPS server. /// Provide paths to a certificate chain and server key (both .pem). /// If no password is provided, a random one will be generated upon running /// the server. Angel.secure(String certificateChainPath, String serverKeyPath, {String password}) : super() { bootstrapContainer(); _serverGenerator = (InternetAddress address, int port) async { var certificateChain = Platform.script.resolve('server_chain.pem').toFilePath(); var serverKey = Platform.script.resolve('server_key.pem').toFilePath(); var serverContext = new SecurityContext(); serverContext.useCertificateChain(certificateChain); serverContext.usePrivateKey(serverKey, password: password ?? _randomString(8)); return await HttpServer.bindSecure(address, port, serverContext); }; } }