platform/lib/src/http/response_context.dart
thosakwe@gmail.com ae4a434477 Coverage start...
2017-05-27 08:39:45 -04:00

420 lines
11 KiB
Dart

library angel_framework.http.response_context;
import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'package:angel_route/angel_route.dart';
import 'package:json_god/json_god.dart' as god;
import 'package:mime/mime.dart';
import '../extensible.dart';
import 'server.dart' show Angel;
import 'controller.dart';
final RegExp _contentType =
new RegExp(r'([^/\n]+)\/\s*([^;\n]+)\s*(;\s*charset=([^$;\n]+))?');
final RegExp _straySlashes = new RegExp(r'(^/+)|(/+$)');
/// Serializes response data into a String.
typedef String ResponseSerializer(data);
/// A convenience wrapper around an outgoing HTTP request.
class ResponseContext extends Extensible {
final _LockableBytesBuilder _buffer = new _LockableBytesBuilder();
final Map<String, String> _headers = {HttpHeaders.SERVER: 'angel'};
bool _isOpen = true,
_isClosed = false;
int _statusCode = 200;
/// The [Angel] instance that is sending a response.
Angel app;
/// Is `Transfer-Encoding` chunked?
bool chunked;
/// Any and all cookies to be sent to the user.
final List<Cookie> cookies = [];
/// Headers that will be sent to the user.
Map<String, String> get headers {
/// If the response is closed, then this getter will return an immutable `Map`.
if (_isClosed)
return new Map<String, String>.unmodifiable(_headers);
else
return _headers;
}
/// Serializes response data into a String.
///
/// The default is conversion into JSON via `package:json_god`.
///
/// If you are 100% sure that your response handlers will only
/// be JSON-encodable objects (i.e. primitives, `List`s and `Map`s),
/// then consider setting [serializer] to `JSON.encode`.
///
/// To set it globally for the whole [app], use the following helper:
/// ```dart
/// app.injectSerializer(JSON.encode);
/// ```
ResponseSerializer serializer = god.serialize;
/// This response's status code.
int get statusCode => _statusCode;
void set statusCode(int value) {
if (_isClosed)
throw _closed();
else
_statusCode = value ?? 200;
}
/// Can we still write to this response?
bool get isOpen => _isOpen;
/// A set of UTF-8 encoded bytes that will be written to the response.
BytesBuilder get buffer => _buffer;
/// Sets the status code to be sent with this response.
@Deprecated('Please use `statusCode=` instead.')
void status(int code) {
statusCode = code;
}
/// The underlying [HttpResponse] under this instance.
final HttpResponse io;
@deprecated
HttpResponse get underlyingRequest {
throw new Exception(
'`ResponseContext#underlyingResponse` is deprecated. Please update your application to use the newer `ResponseContext#io`.');
}
/// Gets the Content-Type header.
ContentType get contentType {
if (!headers.containsKey(HttpHeaders.CONTENT_TYPE)) return null;
var header = headers[HttpHeaders.CONTENT_TYPE];
var match = _contentType.firstMatch(header);
if (match == null)
throw new Exception('Malformed Content-Type response header: "$header".');
if (match[4]?.isNotEmpty != true)
return new ContentType(match[1], match[2]);
else
return new ContentType(match[1], match[2], charset: match[4]);
}
/// Sets the Content-Type header.
void set contentType(ContentType contentType) {
headers[HttpHeaders.CONTENT_TYPE] = contentType.toString();
}
ResponseContext(this.io, this.app);
/// Set this to true if you will manually close the response.
///
/// If `true`, all response finalizers will be skipped.
bool willCloseItself = false;
StateError _closed() => new StateError('Cannot modify a closed response.');
/// Sends a download as a response.
download(File file, {String filename}) async {
if (!_isOpen) throw _closed();
headers["Content-Disposition"] =
'attachment; filename="${filename ?? file.path}"';
headers[HttpHeaders.CONTENT_TYPE] = lookupMimeType(file.path);
headers[HttpHeaders.CONTENT_LENGTH] = file.lengthSync().toString();
buffer.add(await file.readAsBytes());
end();
}
/// Prevents more data from being written to the response, and locks it entire from further editing.
void close() {
_buffer._lock();
_isOpen = false;
_isClosed = true;
}
/// Prevents further request handlers from running on the response, except for response finalizers.
///
/// To disable response finalizers, see [willCloseItself].
void end() {
_isOpen = false;
}
/// Re-opens a closed response. **NEVER USE THIS IN A PLUGIN**.
///
/// To preserve your sanity, don't use it ever. This is solely for internal use.
///
/// You're going to need this one day, and you'll be happy it was added.
void reopen() {
_buffer._reopen();
_isOpen = true;
}
/// Sets a response header to the given value, or retrieves its value.
@Deprecated('Please use `headers` instead.')
header(String key, [String value]) {
if (value == null)
return headers[key];
else
headers[key] = value;
}
/// Serializes JSON to the response.
void json(value) => serialize(value, contentType: ContentType.JSON);
/// Returns a JSONP response.
void jsonp(value, {String callbackName: "callback", contentType}) {
if (_isClosed) throw _closed();
write("$callbackName(${serializer(value)})");
if (contentType != null) {
if (contentType is ContentType)
this.contentType = contentType;
else
headers[HttpHeaders.CONTENT_TYPE] = contentType.toString();
} else
headers[HttpHeaders.CONTENT_TYPE] = 'application/javascript';
end();
}
/// Renders a view to the response stream, and closes the response.
Future render(String view, [Map data]) async {
if (_isClosed) throw _closed();
write(await app.viewGenerator(view, data));
headers[HttpHeaders.CONTENT_TYPE] = ContentType.HTML.toString();
end();
}
/// Redirects to user to the given URL.
///
/// [url] can be a `String`, or a `List`.
/// If it is a `List`, a URI will be constructed
/// based on the provided params.
///
/// See [Router]#navigate for more. :)
void redirect(url, {bool absolute: true, int code: 302}) {
if (_isClosed) throw _closed();
headers
..[HttpHeaders.CONTENT_TYPE] = ContentType.HTML.toString()
..[HttpHeaders.LOCATION] =
url is String ? url : app.navigate(url, absolute: absolute);
statusCode = code ?? 302;
write('''
<!DOCTYPE html>
<html>
<head>
<title>Redirecting...</title>
<meta http-equiv="refresh" content="0; url=$url">
</head>
<body>
<h1>Currently redirecting you...</h1>
<br />
Click <a href="$url">here</a> if you are not automatically redirected...
<script>
window.location = "$url";
</script>
</body>
</html>
''');
end();
}
/// Redirects to the given named [Route].
void redirectTo(String name, [Map params, int code]) {
if (_isClosed) throw _closed();
Route _findRoute(Router r) {
for (Route route in r.routes) {
if (route is SymlinkRoute) {
final m = _findRoute(route.router);
if (m != null) return m;
} else if (route.name == name) return route;
}
return null;
}
Route matched = _findRoute(app);
if (matched != null) {
redirect(matched.makeUri(params), code: code);
return;
}
throw new ArgumentError.notNull('Route to redirect to ($name)');
}
/// Redirects to the given [Controller] action.
void redirectToAction(String action, [Map params, int code]) {
if (_isClosed) throw _closed();
// UserController@show
List<String> split = action.split("@");
if (split.length < 2)
throw new Exception(
"Controller redirects must take the form of 'Controller@action'. You gave: $action");
Controller controller =
app.controller(split[0].replaceAll(_straySlashes, ''));
if (controller == null)
throw new Exception("Could not find a controller named '${split[0]}'");
Route matched = controller.routeMappings[split[1]];
if (matched == null)
throw new Exception(
"Controller '${split[0]}' does not contain any action named '${split[1]}'");
final head =
controller
.findExpose()
.path
.toString()
.replaceAll(_straySlashes, '');
final tail = matched.makeUri(params).replaceAll(_straySlashes, '');
redirect('$head/$tail'.replaceAll(_straySlashes, ''), code: code);
}
/// Copies a file's contents into the response buffer.
Future sendFile(File file,
{int chunkSize, int sleepMs: 0, bool resumable: true}) async {
if (_isClosed) throw _closed();
headers[HttpHeaders.CONTENT_TYPE] = lookupMimeType(file.path);
buffer.add(await file.readAsBytes());
end();
}
/// Serializes data to the response.
///
/// [contentType] can be either a [String], or a [ContentType].
void serialize(value, {contentType}) {
if (_isClosed) throw _closed();
var text = serializer(value);
write(text);
if (contentType is String)
headers[HttpHeaders.CONTENT_TYPE] = contentType;
else if (contentType is ContentType) this.contentType = contentType;
end();
}
/// Streams a file to this response.
///
/// You can optionally transform the file stream with a [codec].
Future streamFile(File file,
{int chunkSize,
int sleepMs: 0,
bool resumable: true,
Codec<List<int>, List<int>> codec}) async {
if (_isClosed) throw _closed();
headers[HttpHeaders.CONTENT_TYPE] = lookupMimeType(file.path);
end();
willCloseItself = true;
Stream stream = codec != null
? file.openRead().transform(codec.encoder)
: file.openRead();
await stream.pipe(io);
}
/// Writes data to the response.
void write(value, {Encoding encoding: UTF8}) {
if (_isClosed)
throw _closed();
else {
if (value is List<int>)
buffer.add(value);
else
buffer.add(encoding.encode(value.toString()));
}
}
}
abstract class _LockableBytesBuilder extends BytesBuilder {
factory _LockableBytesBuilder() => new _LockableBytesBuilderImpl();
void _lock();
void _reopen();
}
class _LockableBytesBuilderImpl implements _LockableBytesBuilder {
bool _closed = false;
final List<int> _data = [];
StateError _deny() =>
new StateError('Cannot modified a closed response\'s buffer.');
@override
void _lock() {
_closed = true;
}
@override
void _reopen() {
_closed = false;
}
@override
void add(List<int> bytes) {
if (_closed)
throw _deny();
else {
_data.addAll(bytes);
}
}
@override
void addByte(int byte) {
if (_closed)
throw _deny();
else {
_data.add(byte);
}
}
@override
void clear() {
if (_closed)
throw _deny();
else {
_data.clear();
}
}
@override
bool get isEmpty => _data.isEmpty;
@override
bool get isNotEmpty => _data.isNotEmpty;
@override
int get length => _data.length;
@override
List<int> takeBytes() {
if (_closed)
return toBytes();
else {
var r = new List<int>.from(_data);
clear();
return r;
}
}
@override
List<int> toBytes() {
return _data;
}
}