protected static void writeResponse(
ChannelHandlerContext ctx,
Response response,
HttpResponse nettyResponse,
HttpRequest nettyRequest) {
Logger.trace("writeResponse: begin");
byte[] content = null;
final boolean keepAlive = isKeepAlive(nettyRequest);
if (nettyRequest.getMethod().equals(HttpMethod.HEAD)) {
content = new byte[0];
} else {
content = response.out.toByteArray();
}
ChannelBuffer buf = ChannelBuffers.copiedBuffer(content);
nettyResponse.setContent(buf);
if (keepAlive) {
// Add 'Content-Length' header only for a keep-alive connection.
Logger.trace("writeResponse: content length [" + response.out.size() + "]");
setContentLength(nettyResponse, response.out.size());
}
ChannelFuture f = ctx.getChannel().write(nettyResponse);
// Decide whether to close the connection or not.
if (!keepAlive) {
// Close the connection when the whole content is written out.
f.addListener(ChannelFutureListener.CLOSE);
}
Logger.trace("writeResponse: end");
}
public static void serve404(
NotFound e, ChannelHandlerContext ctx, Request request, HttpRequest nettyRequest) {
Logger.trace("serve404: begin");
HttpResponse nettyResponse =
new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.NOT_FOUND);
nettyResponse.setHeader(SERVER, signature);
nettyResponse.setHeader(CONTENT_TYPE, "text/html");
Map<String, Object> binding = getBindingForErrors(e, false);
String format = Request.current().format;
if (format == null) {
format = "txt";
}
nettyResponse.setHeader(
CONTENT_TYPE, (MimeTypes.getContentType("404." + format, "text/plain")));
String errorHtml = TemplateLoader.load("errors/404." + format).render(binding);
try {
ChannelBuffer buf = ChannelBuffers.copiedBuffer(errorHtml.getBytes("utf-8"));
nettyResponse.setContent(buf);
ChannelFuture writeFuture = ctx.getChannel().write(nettyResponse);
writeFuture.addListener(ChannelFutureListener.CLOSE);
} catch (UnsupportedEncodingException fex) {
Logger.error(fex, "(utf-8 ?)");
}
Logger.trace("serve404: end");
}
@Override
public void execute() throws Exception {
if (!ctx.getChannel().isConnected()) {
try {
ctx.getChannel().close();
} catch (Throwable e) {
// Ignore
}
return;
}
// Check the exceeded size before re rendering so we can render the error if the size is
// exceeded
saveExceededSizeError(nettyRequest, request, response);
ActionInvoker.invoke(request, response);
}
@Override
public void onException(Throwable e) {
Logger.error(
e,
"Internal Server Error in WebSocket (closing the socket) for request %s",
request.method + " " + request.url);
ctx.getChannel().close();
super.onException(e);
}
static String getRemoteIPAddress(ChannelHandlerContext ctx) {
String fullAddress =
((InetSocketAddress) ctx.getChannel().getRemoteAddress()).getAddress().getHostAddress();
if (fullAddress.matches("/[0-9]+[.][0-9]+[.][0-9]+[.][0-9]+[:][0-9]+")) {
fullAddress = fullAddress.substring(1);
fullAddress = fullAddress.substring(0, fullAddress.indexOf(":"));
} else if (fullAddress.matches(".*[%].*")) {
fullAddress = fullAddress.substring(0, fullAddress.indexOf("%"));
}
return fullAddress;
}
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
HttpRequest request = (HttpRequest) e.getMessage();
if (request.getContent().readableBytes() == 0) {
BaseTransport.respond(e.getChannel(), INTERNAL_SERVER_ERROR, "Payload expected.");
return;
}
transportMetrics.messagesReceived.mark();
transportMetrics.messagesReceivedSize.update(request.getContent().readableBytes());
// logger.debug("Received {}", request.getContent().toString(CharsetUtil.UTF_8));
String contentTypeHeader = request.getHeader(CONTENT_TYPE);
if (contentTypeHeader == null) {
contentTypeHeader = BaseTransport.CONTENT_TYPE_PLAIN;
}
String decodedContent;
if (BaseTransport.CONTENT_TYPE_FORM.equals(contentTypeHeader)) {
QueryStringDecoder decoder =
new QueryStringDecoder("?" + request.getContent().toString(CharsetUtil.UTF_8));
List<String> d = decoder.getParameters().get("d");
if (d == null) {
BaseTransport.respond(e.getChannel(), INTERNAL_SERVER_ERROR, "Payload expected.");
return;
}
decodedContent = d.get(0);
} else {
decodedContent = request.getContent().toString(CharsetUtil.UTF_8);
}
if (decodedContent.length() == 0) {
BaseTransport.respond(e.getChannel(), INTERNAL_SERVER_ERROR, "Payload expected.");
return;
}
String[] messages = MAPPER.readValue(decodedContent, String[].class);
for (String message : messages) {
SockJsMessage jsMessage = new SockJsMessage(message);
ctx.sendUpstream(new UpstreamMessageEvent(e.getChannel(), jsMessage, e.getRemoteAddress()));
}
if (isJsonpEnabled) {
BaseTransport.respond(e.getChannel(), OK, "ok");
} else {
BaseTransport.respond(e.getChannel(), NO_CONTENT, "");
}
}
public void serveStatic(
RenderStatic renderStatic,
ChannelHandlerContext ctx,
Request request,
Response response,
HttpRequest nettyRequest,
MessageEvent e) {
Logger.trace("serveStatic: begin");
HttpResponse nettyResponse =
new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.valueOf(response.status));
if (exposePlayServer) {
nettyResponse.setHeader(SERVER, signature);
}
try {
VirtualFile file = Play.getVirtualFile(renderStatic.file);
if (file != null && file.exists() && file.isDirectory()) {
file = file.child("index.html");
if (file != null) {
renderStatic.file = file.relativePath();
}
}
if ((file == null || !file.exists())) {
serve404(
new NotFound("The file " + renderStatic.file + " does not exist"),
ctx,
request,
nettyRequest);
} else {
boolean raw = false;
for (PlayPlugin plugin : Play.plugins) {
if (plugin.serveStatic(file, Request.current(), Response.current())) {
raw = true;
break;
}
}
if (raw) {
copyResponse(ctx, request, response, nettyRequest);
} else {
final File localFile = file.getRealFile();
final boolean keepAlive = isKeepAlive(nettyRequest);
nettyResponse = addEtag(nettyRequest, nettyResponse, localFile);
if (nettyResponse.getStatus().equals(HttpResponseStatus.NOT_MODIFIED)) {
Channel ch = e.getChannel();
// Write the initial line and the header.
ChannelFuture writeFuture = ch.write(nettyResponse);
if (!keepAlive) {
// Write the content.
writeFuture.addListener(ChannelFutureListener.CLOSE);
}
} else {
final RandomAccessFile raf = new RandomAccessFile(localFile, "r");
try {
long fileLength = raf.length();
Logger.trace("keep alive " + keepAlive);
Logger.trace(
"content type " + (MimeTypes.getContentType(localFile.getName(), "text/plain")));
if (keepAlive && !nettyResponse.getStatus().equals(HttpResponseStatus.NOT_MODIFIED)) {
// Add 'Content-Length' header only for a keep-alive connection.
Logger.trace("file length " + fileLength);
setContentLength(nettyResponse, fileLength);
}
nettyResponse.setHeader(
CONTENT_TYPE, (MimeTypes.getContentType(localFile.getName(), "text/plain")));
Channel ch = e.getChannel();
// Write the initial line and the header.
ChannelFuture writeFuture = ch.write(nettyResponse);
// Write the content.
if (!nettyRequest.getMethod().equals(HttpMethod.HEAD)) {
writeFuture = ch.write(new ChunkedFile(raf, 0, fileLength, 8192));
} else {
raf.close();
}
if (!keepAlive) {
// Close the connection when the whole content is written out.
writeFuture.addListener(ChannelFutureListener.CLOSE);
}
} catch (Throwable exx) {
try {
raf.close();
} catch (Throwable ex) {
/* Left empty */
}
try {
ctx.getChannel().close();
} catch (Throwable ex) {
/* Left empty */
}
}
}
}
}
} catch (Throwable ez) {
Logger.error(ez, "serveStatic for request %s", request.method + " " + request.url);
try {
HttpResponse errorResponse =
new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.INTERNAL_SERVER_ERROR);
ChannelBuffer buf =
ChannelBuffers.copiedBuffer("Internal Error (check logs)".getBytes("utf-8"));
errorResponse.setContent(buf);
ChannelFuture future = ctx.getChannel().write(errorResponse);
future.addListener(ChannelFutureListener.CLOSE);
} catch (Exception ex) {
Logger.error(ez, "serveStatic for request %s", request.method + " " + request.url);
}
}
Logger.trace("serveStatic: end");
}
// TODO: add request and response as parameter
public static void serve500(Exception e, ChannelHandlerContext ctx, HttpRequest nettyRequest) {
Logger.trace("serve500: begin");
HttpResponse nettyResponse =
new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.INTERNAL_SERVER_ERROR);
if (exposePlayServer) {
nettyResponse.setHeader(SERVER, signature);
}
Request request = Request.current();
Response response = Response.current();
try {
if (!(e instanceof PlayException)) {
e = new play.exceptions.UnexpectedException(e);
}
// Flush some cookies
try {
Map<String, Http.Cookie> cookies = response.cookies;
for (Http.Cookie cookie : cookies.values()) {
CookieEncoder encoder = new CookieEncoder(true);
Cookie c = new DefaultCookie(cookie.name, cookie.value);
c.setSecure(cookie.secure);
c.setPath(cookie.path);
if (cookie.domain != null) {
c.setDomain(cookie.domain);
}
if (cookie.maxAge != null) {
c.setMaxAge(cookie.maxAge);
}
c.setHttpOnly(cookie.httpOnly);
encoder.addCookie(c);
nettyResponse.addHeader(SET_COOKIE, encoder.encode());
}
} catch (Exception exx) {
Logger.error(e, "Trying to flush cookies");
// humm ?
}
Map<String, Object> binding = getBindingForErrors(e, true);
String format = request.format;
if (format == null) {
format = "txt";
}
nettyResponse.setHeader(
"Content-Type", (MimeTypes.getContentType("500." + format, "text/plain")));
try {
String errorHtml = TemplateLoader.load("errors/500." + format).render(binding);
ChannelBuffer buf = ChannelBuffers.copiedBuffer(errorHtml.getBytes("utf-8"));
nettyResponse.setContent(buf);
ChannelFuture writeFuture = ctx.getChannel().write(nettyResponse);
writeFuture.addListener(ChannelFutureListener.CLOSE);
Logger.error(
e, "Internal Server Error (500) for request %s", request.method + " " + request.url);
} catch (Throwable ex) {
Logger.error(
e, "Internal Server Error (500) for request %s", request.method + " " + request.url);
Logger.error(ex, "Error during the 500 response generation");
try {
ChannelBuffer buf =
ChannelBuffers.copiedBuffer("Internal Error (check logs)".getBytes("utf-8"));
nettyResponse.setContent(buf);
ChannelFuture writeFuture = ctx.getChannel().write(nettyResponse);
writeFuture.addListener(ChannelFutureListener.CLOSE);
} catch (UnsupportedEncodingException fex) {
Logger.error(fex, "(utf-8 ?)");
}
}
} catch (Throwable exxx) {
try {
ChannelBuffer buf =
ChannelBuffers.copiedBuffer("Internal Error (check logs)".getBytes("utf-8"));
nettyResponse.setContent(buf);
ChannelFuture writeFuture = ctx.getChannel().write(nettyResponse);
writeFuture.addListener(ChannelFutureListener.CLOSE);
} catch (Exception fex) {
Logger.error(fex, "(utf-8 ?)");
}
if (exxx instanceof RuntimeException) {
throw (RuntimeException) exxx;
}
throw new RuntimeException(exxx);
}
Logger.trace("serve500: end");
}
public Request parseRequest(ChannelHandlerContext ctx, HttpRequest nettyRequest)
throws Exception {
Logger.trace("parseRequest: begin");
Logger.trace("parseRequest: URI = " + nettyRequest.getUri());
int index = nettyRequest.getUri().indexOf("?");
String querystring = "";
String uri = nettyRequest.getUri();
// Remove domain and port from URI if it's present.
if (uri.startsWith("http://") || uri.startsWith("https://")) {
// Begins searching / after 9th character (last / of https://)
uri = uri.substring(uri.indexOf("/", 9));
}
String path = URLDecoder.decode(uri, "UTF-8");
if (index != -1) {
path = URLDecoder.decode(uri.substring(0, index), "UTF-8");
querystring = uri.substring(index + 1);
}
final Request request = new Request();
request.remoteAddress = getRemoteIPAddress(ctx);
request.method = nettyRequest.getMethod().getName();
request.path = path;
request.querystring = querystring;
final String contentType = nettyRequest.getHeader(CONTENT_TYPE);
if (contentType != null) {
request.contentType = contentType.split(";")[0].trim().toLowerCase();
} else {
request.contentType = "text/html";
}
if (nettyRequest.getHeader("X-HTTP-Method-Override") != null) {
request.method = nettyRequest.getHeader("X-HTTP-Method-Override").intern();
}
ChannelBuffer b = nettyRequest.getContent();
if (b instanceof FileChannelBuffer) {
FileChannelBuffer buffer = (FileChannelBuffer) b;
// An error occurred
Integer max =
Integer.valueOf(Play.configuration.getProperty("play.netty.maxContentLength", "-1"));
request.body = buffer.getInputStream();
if (!(max == -1 || request.body.available() < max)) {
request.body = new ByteArrayInputStream(new byte[0]);
}
} else {
ByteArrayOutputStream out = new ByteArrayOutputStream();
IOUtils.copy(new ChannelBufferInputStream(b), out);
byte[] n = out.toByteArray();
request.body = new ByteArrayInputStream(n);
}
request.url = uri;
request.host = nettyRequest.getHeader(HOST);
request.isLoopback =
((InetSocketAddress) ctx.getChannel().getRemoteAddress()).getAddress().isLoopbackAddress()
&& request.host.matches("^127\\.0\\.0\\.1:?[0-9]*$");
if (request.host == null) {
request.host = "";
request.port = 80;
request.domain = "";
} else {
if (request.host.contains(":")) {
final String[] host = request.host.split(":");
request.port = Integer.parseInt(host[1]);
request.domain = host[0];
} else {
request.port = 80;
request.domain = request.host;
}
}
if (Play.configuration.containsKey("XForwardedSupport")
&& nettyRequest.getHeader("X-Forwarded-For") != null) {
if (!Arrays.asList(
Play.configuration.getProperty("XForwardedSupport", "127.0.0.1").split(","))
.contains(request.remoteAddress)) {
throw new RuntimeException(
"This proxy request is not authorized: " + request.remoteAddress);
} else {
request.secure =
("https".equals(Play.configuration.get("XForwardedProto"))
|| "https".equals(nettyRequest.getHeader("X-Forwarded-Proto"))
|| "on".equals(nettyRequest.getHeader("X-Forwarded-Ssl")));
if (Play.configuration.containsKey("XForwardedHost")) {
request.host = (String) Play.configuration.get("XForwardedHost");
} else if (nettyRequest.getHeader("X-Forwarded-Host") != null) {
request.host = nettyRequest.getHeader("X-Forwarded-Host");
}
if (nettyRequest.getHeader("X-Forwarded-For") != null) {
request.remoteAddress = nettyRequest.getHeader("X-Forwarded-For");
}
}
}
addToRequest(nettyRequest, request);
request.resolveFormat();
request._init();
Logger.trace("parseRequest: end");
return request;
}
public void copyResponse(
ChannelHandlerContext ctx, Request request, Response response, HttpRequest nettyRequest)
throws Exception {
Logger.trace("copyResponse: begin");
// response.out.flush();
// Decide whether to close the connection or not.
HttpResponse nettyResponse =
new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.valueOf(response.status));
if (exposePlayServer) {
nettyResponse.setHeader(SERVER, signature);
}
if (response.contentType != null) {
nettyResponse.setHeader(
CONTENT_TYPE,
response.contentType
+ (response.contentType.startsWith("text/")
&& !response.contentType.contains("charset")
? "; charset=utf-8"
: ""));
} else {
nettyResponse.setHeader(CONTENT_TYPE, "text/plain; charset=utf-8");
}
addToResponse(response, nettyResponse);
final Object obj = response.direct;
File file = null;
ChunkedInput stream = null;
InputStream is = null;
if (obj instanceof File) {
file = (File) obj;
} else if (obj instanceof InputStream) {
is = (InputStream) obj;
} else if (obj instanceof ChunkedInput) {
stream = (ChunkedInput) obj;
}
final boolean keepAlive = isKeepAlive(nettyRequest);
if (file != null && file.isFile()) {
try {
nettyResponse = addEtag(nettyRequest, nettyResponse, file);
if (nettyResponse.getStatus().equals(HttpResponseStatus.NOT_MODIFIED)) {
Channel ch = ctx.getChannel();
// Write the initial line and the header.
ChannelFuture writeFuture = ch.write(nettyResponse);
if (!keepAlive) {
// Close the connection when the whole content is written out.
writeFuture.addListener(ChannelFutureListener.CLOSE);
}
} else {
nettyResponse.setHeader(
CONTENT_TYPE, MimeTypes.getContentType(file.getName(), "text/plain"));
final RandomAccessFile raf = new RandomAccessFile(file, "r");
try {
long fileLength = raf.length();
if (keepAlive) {
// Add 'Content-Length' header only for a keep-alive connection.
Logger.trace("file length is [" + fileLength + "]");
setContentLength(nettyResponse, fileLength);
}
Channel ch = ctx.getChannel();
// Write the initial line and the header.
ChannelFuture writeFuture = ch.write(nettyResponse);
// Write the content.
// If it is not a HEAD
if (!nettyRequest.getMethod().equals(HttpMethod.HEAD)) {
writeFuture = ch.write(new ChunkedFile(raf, 0, fileLength, 8192));
} else {
raf.close();
}
if (!keepAlive) {
// Close the connection when the whole content is written out.
writeFuture.addListener(ChannelFutureListener.CLOSE);
}
} catch (Throwable exx) {
try {
raf.close();
} catch (Throwable ex) {
/* Left empty */
}
try {
ctx.getChannel().close();
} catch (Throwable ex) {
/* Left empty */
}
}
}
} catch (Exception e) {
throw e;
}
} else if (is != null) {
ChannelFuture writeFuture = ctx.getChannel().write(nettyResponse);
if (!nettyRequest.getMethod().equals(HttpMethod.HEAD)
&& !nettyResponse.getStatus().equals(HttpResponseStatus.NOT_MODIFIED)) {
writeFuture = ctx.getChannel().write(new ChunkedStream(is));
} else {
is.close();
}
if (!keepAlive) {
writeFuture.addListener(ChannelFutureListener.CLOSE);
}
} else if (stream != null) {
ChannelFuture writeFuture = ctx.getChannel().write(nettyResponse);
if (!nettyRequest.getMethod().equals(HttpMethod.HEAD)
&& !nettyResponse.getStatus().equals(HttpResponseStatus.NOT_MODIFIED)) {
writeFuture = ctx.getChannel().write(stream);
} else {
stream.close();
}
if (!keepAlive) {
writeFuture.addListener(ChannelFutureListener.CLOSE);
}
} else {
writeResponse(ctx, response, nettyResponse, nettyRequest);
}
Logger.trace("copyResponse: end");
}
private void websocketHandshake(final ChannelHandlerContext ctx, HttpRequest req, MessageEvent e)
throws Exception {
// Create the WebSocket handshake response.
HttpResponse res =
new DefaultHttpResponse(
HttpVersion.HTTP_1_1, new HttpResponseStatus(101, "Web Socket Protocol Handshake"));
res.addHeader(HttpHeaders.Names.UPGRADE, HttpHeaders.Values.WEBSOCKET);
res.addHeader(CONNECTION, HttpHeaders.Values.UPGRADE);
// Fill in the headers and contents depending on handshake method.
if (req.containsHeader(SEC_WEBSOCKET_KEY1) && req.containsHeader(SEC_WEBSOCKET_KEY2)) {
// New handshake method with a challenge:
res.addHeader(SEC_WEBSOCKET_ORIGIN, req.getHeader(ORIGIN));
res.addHeader(
SEC_WEBSOCKET_LOCATION, "ws://" + req.getHeader(HttpHeaders.Names.HOST) + req.getUri());
String protocol = req.getHeader(SEC_WEBSOCKET_PROTOCOL);
if (protocol != null) {
res.addHeader(SEC_WEBSOCKET_PROTOCOL, protocol);
}
// Calculate the answer of the challenge.
String key1 = req.getHeader(SEC_WEBSOCKET_KEY1);
String key2 = req.getHeader(SEC_WEBSOCKET_KEY2);
int a =
(int)
(Long.parseLong(key1.replaceAll("[^0-9]", ""))
/ key1.replaceAll("[^ ]", "").length());
int b =
(int)
(Long.parseLong(key2.replaceAll("[^0-9]", ""))
/ key2.replaceAll("[^ ]", "").length());
long c = req.getContent().readLong();
ChannelBuffer input = ChannelBuffers.buffer(16);
input.writeInt(a);
input.writeInt(b);
input.writeLong(c);
try {
ChannelBuffer output =
ChannelBuffers.wrappedBuffer(MessageDigest.getInstance("MD5").digest(input.array()));
res.setContent(output);
} catch (NoSuchAlgorithmException ex) {
throw new UnexpectedException(ex);
}
} else {
// Old handshake method with no challenge:
res.addHeader(WEBSOCKET_ORIGIN, req.getHeader(ORIGIN));
res.addHeader(
WEBSOCKET_LOCATION, "ws://" + req.getHeader(HttpHeaders.Names.HOST) + req.getUri());
String protocol = req.getHeader(WEBSOCKET_PROTOCOL);
if (protocol != null) {
res.addHeader(WEBSOCKET_PROTOCOL, protocol);
}
}
// Keep the original request
Http.Request request = parseRequest(ctx, req);
// Route the websocket request
request.method = "WS";
Map<String, String> route = Router.route(request.method, request.path);
if (!route.containsKey("action")) {
// No route found to handle this websocket connection
ctx.getChannel()
.write(new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.NOT_FOUND));
return;
}
// Upgrade the connection and send the handshake response.
ChannelPipeline p = ctx.getChannel().getPipeline();
p.remove("aggregator");
p.replace("decoder", "wsdecoder", new WebSocketFrameDecoder());
// Connect
ctx.getChannel().write(res);
p.replace("encoder", "wsencoder", new WebSocketFrameEncoder());
req.setMethod(new HttpMethod("WEBSOCKET"));
// Inbound
Http.Inbound inbound =
new Http.Inbound() {
@Override
public boolean isOpen() {
return ctx.getChannel().isOpen();
}
};
channels.put(ctx, inbound);
// Outbound
Http.Outbound outbound =
new Http.Outbound() {
final List<ChannelFuture> writeFutures =
Collections.synchronizedList(new ArrayList<ChannelFuture>());
Promise<Void> closeTask;
synchronized void writeAndClose(ChannelFuture writeFuture) {
if (!writeFuture.isDone()) {
writeFutures.add(writeFuture);
writeFuture.addListener(
new ChannelFutureListener() {
public void operationComplete(ChannelFuture cf) throws Exception {
writeFutures.remove(cf);
futureClose();
}
});
}
}
void futureClose() {
if (closeTask != null && writeFutures.isEmpty()) {
closeTask.invoke(null);
}
}
@Override
public void send(String data) {
if (!isOpen()) {
throw new IllegalStateException("The outbound channel is closed");
}
writeAndClose(ctx.getChannel().write(new DefaultWebSocketFrame(data)));
}
@Override
public void send(byte opcode, byte[] data, int offset, int length) {
if (!isOpen()) {
throw new IllegalStateException("The outbound channel is closed");
}
writeAndClose(
ctx.getChannel()
.write(new DefaultWebSocketFrame(opcode, wrappedBuffer(data, offset, length))));
}
@Override
public synchronized boolean isOpen() {
return ctx.getChannel().isOpen() && closeTask == null;
}
@Override
public synchronized void close() {
closeTask = new Promise<Void>();
closeTask.onRedeem(
new Action<Promise<Void>>() {
public void invoke(Promise<Void> completed) {
writeFutures.clear();
ctx.getChannel().disconnect();
closeTask = null;
}
});
futureClose();
}
};
Invoker.invoke(new WebSocketInvocation(route, request, inbound, outbound, ctx, e));
}