@Override public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception { if (e.getCause() instanceof WebSocketHandshakeException) { DefaultHttpResponse response = new DefaultHttpResponse(HTTP_1_1, HttpResponseStatus.BAD_REQUEST); response.setContent(ChannelBuffers.wrappedBuffer(e.getCause().getMessage().getBytes())); ctx.getChannel().write(response).addListener(ChannelFutureListener.CLOSE); } else { ctx.getChannel().close(); } }
private void sendError(ChannelHandlerContext ctx, String message, HttpResponseStatus status) { HttpResponse response = new DefaultHttpResponse(HTTP_1_1, status); response.setHeader(CONTENT_TYPE, "text/plain; charset=UTF-8"); response.setContent( ChannelBuffers.copiedBuffer(message, CharsetUtil.UTF_8)); // Close the connection as soon as the error message is sent. ctx.getChannel().write(response).addListener(ChannelFutureListener.CLOSE); }
private static void forbidden(final ChannelHandlerContext ctx, final HttpRequest request) { ctx.getChannel().write(new DefaultHttpResponse(request.getProtocolVersion(), FORBIDDEN)) .addListener(ChannelFutureListener.CLOSE); }
private void writeResponse(Channel channel) { ChannelBuffer buf = ChannelBuffers.copiedBuffer( this.responseContent.toString(), CharsetUtil.UTF_8); this.responseContent.setLength(0); boolean close = ("close".equalsIgnoreCase(this.request .getHeader("Connection"))) || ((this.request.getProtocolVersion() .equals(HttpVersion.HTTP_1_0)) && (!"keep-alive" .equalsIgnoreCase(this.request.getHeader("Connection")))); HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK); response.setContent(buf); response.setHeader("Content-Type", "text/plain; charset=UTF-8"); if (!close) { response.setHeader("Content-Length", String.valueOf(buf.readableBytes())); } ChannelFuture future = channel.write(response); if (close) future.addListener(ChannelFutureListener.CLOSE); }
protected void sendError(ChannelHandlerContext ctx, String message, HttpResponseStatus status) { HttpResponse response = new DefaultHttpResponse(HTTP_1_1, status); response.headers().add(CONTENT_TYPE, "text/plain; charset=UTF-8"); // Put shuffle version into http header response.headers().add(ShuffleHeader.HTTP_HEADER_NAME, ShuffleHeader.DEFAULT_HTTP_HEADER_NAME); response.headers().add(ShuffleHeader.HTTP_HEADER_VERSION, ShuffleHeader.DEFAULT_HTTP_HEADER_VERSION); response.setContent( ChannelBuffers.copiedBuffer(message, CharsetUtil.UTF_8)); // Close the connection as soon as the error message is sent. ctx.getChannel().write(response).addListener(ChannelFutureListener.CLOSE); }
protected void sendError(ChannelHandlerContext ctx, String msg, HttpResponseStatus status, Map<String, String> headers) { HttpResponse response = new DefaultHttpResponse(HTTP_1_1, status); response.headers().set(CONTENT_TYPE, "text/plain; charset=UTF-8"); // Put shuffle version into http header response.headers().set(ShuffleHeader.HTTP_HEADER_NAME, ShuffleHeader.DEFAULT_HTTP_HEADER_NAME); response.headers().set(ShuffleHeader.HTTP_HEADER_VERSION, ShuffleHeader.DEFAULT_HTTP_HEADER_VERSION); for (Map.Entry<String, String> header : headers.entrySet()) { response.headers().set(header.getKey(), header.getValue()); } response.setContent( ChannelBuffers.copiedBuffer(msg, CharsetUtil.UTF_8)); // Close the connection as soon as the error message is sent. ctx.getChannel().write(response).addListener(ChannelFutureListener.CLOSE); }
long startTimeInMs) throws Exception { ChannelBuffer responseContent = ChannelBuffers.dynamicBuffer(this.responseValue.length); responseContent.writeBytes(responseValue); HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK); response.setHeader(CONTENT_TYPE, "binary"); response.setHeader(CONTENT_TRANSFER_ENCODING, "binary"); response.setContent(responseContent); response.setHeader(CONTENT_LENGTH, response.getContent().readableBytes()); this.messageEvent.getChannel().write(response);
private void handleHttpRequest(ChannelHandlerContext ctx, HttpRequest req) throws Exception { if (req.getMethod() != HttpMethod.GET) { sendHttpResponse( ctx, req, new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.FORBIDDEN)); return; if (req.getUri().equals(WEBSOCKET_PATH) && Values.UPGRADE.equalsIgnoreCase(req.getHeader(Names.CONNECTION)) && HttpResponse res = new DefaultHttpResponse( HttpVersion.HTTP_1_1, new HttpResponseStatus(101, "Web Socket Protocol Handshake")); res.addHeader(Names.UPGRADE, Values.WEBSOCKET); res.addHeader(Names.CONNECTION, Values.UPGRADE); res.addHeader(Names.SEC_WEBSOCKET_ORIGIN, req.getHeader(Names.ORIGIN)); ChannelPipeline p = ctx.getChannel().getPipeline(); p.remove("http-aggregator"); p.replace("http-decoder", "ws-decoder", new WebSocketFrameDecoder()); ctx.getChannel().write(res); ctx, req, new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.FORBIDDEN));
private void _write(String message) { if(!this.open) return; HttpResponse res = new DefaultHttpResponse(HTTP_1_1, HttpResponseStatus.OK); res.addHeader(CONTENT_TYPE, "text/plain; charset=UTF-8"); res.addHeader("Access-Control-Allow-Origin", "*"); res.addHeader("Access-Control-Allow-Credentials", "true"); res.addHeader("Connection", "keep-alive"); res.setContent(ChannelBuffers.copiedBuffer(message, CharsetUtil.UTF_8)); setContentLength(res, res.getContent().readableBytes()); // Send the response and close the connection if necessary. Channel chan = ctx.getChannel(); if(chan.isOpen()) { ChannelFuture f = chan.write(res); if (!isKeepAlive(req) || res.getStatus().getCode() != 200) { f.addListener(ChannelFutureListener.CLOSE); } } this.connected = false; }
/** * Writes a HTTP 404 response to the client. * * @param ctx * The Netty context. * @param requestedUri * The URI requested by the client. */ private void writeResourceNotFound(final ChannelHandlerContext ctx, String requestedUri) { // Write the HTTP header to the client. DefaultHttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_0, HttpResponseStatus.NOT_FOUND); response.headers().add("Content-Type", "text/plain"); // Send the 404 message to the client. ChannelBuffer buffer = ChannelBuffers.copiedBuffer("The requested resource does not exist: " + requestedUri, CharsetUtil.UTF_8); response.setContent(buffer); // Write the header. Use a new future because the future we've been // passed is for upstream. ChannelFuture headerFuture = Channels.future(ctx.getChannel()); Channels.write(ctx, headerFuture, response); // Wait for the previous operation to finish and then close the channel. headerFuture.addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) { ctx.getChannel().close(); } }); }
@Override public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception { // We have to redirect to https://, as it was targeting http:// // Redirect to the root as we don't know the url at that point if (e.getCause() instanceof SSLException) { Logger.debug(e.getCause(), ""); InetSocketAddress inet = ((InetSocketAddress) ctx.getAttachment()); ctx.getPipeline().remove("ssl"); HttpResponse nettyResponse = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.TEMPORARY_REDIRECT); nettyResponse.headers().set(LOCATION, "https://" + inet.getHostName() + ":" + Server.httpsPort + "/"); ChannelFuture writeFuture = ctx.getChannel().write(nettyResponse); writeFuture.addListener(ChannelFutureListener.CLOSE); } else { Logger.error(e.getCause(), ""); e.getChannel().close(); } }
HttpRequest request = (HttpRequest) e.getMessage(); if (request.getMethod() == HttpMethod.OPTIONS) { HttpResponse response = new DefaultHttpResponse(HTTP_1_1, HttpResponseStatus.OK); response.addHeader("Set-Cookie", "hadoop-auth=1234"); e.getChannel().write(response).addListener(ChannelFutureListener.CLOSE); } else if (request.getMethod() != GET) { e.getChannel().close(); while (iter.hasNext()) { Map.Entry<String, Handler> entry = iter.next(); if (request.getUri().contains(entry.getKey())) { Handler handler = entry.getValue(); try { } catch (AssertionError ee) { TestDelegationTokenRemoteFetcher.this.assertionError = ee; HttpResponse response = new DefaultHttpResponse(HTTP_1_1, HttpResponseStatus.BAD_REQUEST); response.setContent(ChannelBuffers.copiedBuffer(ee.getMessage(), Charset.defaultCharset())); e.getChannel().write(response).addListener(ChannelFutureListener.CLOSE);
String auth = msg.getHeader(HttpHeaders.Names.AUTHORIZATION); String accessToken = null; logEntry.setClientIP(((InetSocketAddress) ctx.getChannel().getRemoteAddress()).getAddress()); logEntry.setRequestLine(msg.getMethod(), msg.getUri(), msg.getProtocolVersion()); HttpResponse httpResponse = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.UNAUTHORIZED); logEntry.setResponseCode(HttpResponseStatus.UNAUTHORIZED.getCode()); httpResponse.addHeader(HttpHeaders.Names.WWW_AUTHENTICATE, String.format("Bearer realm=\"%s\"", realm)); LOG.debug("Authentication failed due to missing token"); httpResponse.addHeader(HttpHeaders.Names.WWW_AUTHENTICATE, String.format("Bearer realm=\"%s\" error=\"invalid_token\"" + " error_description=\"%s\"", realm, tokenState.getMsg())); ChannelBuffer content = ChannelBuffers.wrappedBuffer(jsonObject.toString().getBytes(Charsets.UTF_8)); httpResponse.setContent(content); int contentLength = content.readableBytes(); httpResponse.setHeader(HttpHeaders.Names.CONTENT_LENGTH, contentLength); ChannelFuture writeFuture = Channels.future(inboundChannel); Channels.write(ctx, writeFuture, httpResponse); writeFuture.addListener(ChannelFutureListener.CLOSE); return false; } else {
private void handle(HttpResponse message) throws Exception { State state = getState(State.class); // convert back to netty http response org.jboss.netty.handler.codec.http.HttpResponse nettyResponse = new DefaultHttpResponse(HTTP_1_1, HttpResponseStatus.valueOf(message.getStatusCode())); // @todo: copy the headers from the message HttpHeaders.setHeader(nettyResponse,HttpHeaders.Names.CONTENT_TYPE,message.getContentType()); nettyResponse.setContent(ChannelBuffers.wrappedBuffer(message.getContent())); // we don't support keep alive as of yet state.getResponseChannel().write(nettyResponse).addListener(ChannelFutureListener.CLOSE); // need to remove myself getSystem().stop(getSelf()); }
@Override public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception { HttpServerChannelHandler handler = (HttpServerChannelHandler) ctx.getAttachment(); if (handler != null) { handler.exceptionCaught(ctx, e); ctx.getChannel().close(); } else { HttpResponse response = new DefaultHttpResponse(HTTP_1_1, NOT_FOUND); response.headers().set(Exchange.CONTENT_TYPE, "text/plain"); response.headers().set(Exchange.CONTENT_LENGTH, 0); response.setContent(ChannelBuffers.copiedBuffer(new byte[]{})); ctx.getChannel().write(response).syncUninterruptibly(); ctx.getChannel().close();
@Override public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception { org.jboss.netty.handler.codec.http.HttpRequest nettyRequest = (org.jboss.netty.handler.codec.http.HttpRequest) e.getMessage(); // convert request to our internal request Map<String,List<String>> headers = new HashMap<String,List<String>>(); for (String headerName : nettyRequest.headers().names()) { headers.put(headerName,nettyRequest.headers().getAll(headerName)); } // see if we have a body byte[] content = null; if(nettyRequest.getContent().hasArray() && nettyRequest.getContent().array().length > 0) { content = nettyRequest.getContent().array(); } else if(nettyRequest.getContent().readableBytes() > 0) { // netty content not backed by array, need to copy content = new byte[nettyRequest.getContent().readableBytes()]; nettyRequest.getContent().readBytes(content); } HttpRequest request = new HttpRequest(nettyRequest.getMethod().getName(),new URI(nettyRequest.getUri()).getPath(),headers,content); // create a temp actor to handle the response ActorRef replyActor = actorSystem.tempActorOf(HttpServiceResponseHandler.class, new HttpServiceResponseHandler.State(ctx.getChannel())); // put the actor in the attachment to propagate disconnects ctx.setAttachment(replyActor); // async handling if(!httpService.doDispatch(request,replyActor)) { // send 404 ctx.getChannel().write(new DefaultHttpResponse(HttpVersion.HTTP_1_1,HttpResponseStatus.NOT_FOUND)).addListener(ChannelFutureListener.CLOSE); actorSystem.stop(replyActor); } }
@Override public void failure(Throwable error) { log.error("Uncaught exception in transport layer. This is likely a bug, closing channel.", error); if (channel.isOpen()) { if (channel.isWritable()) { final DefaultHttpResponse internalServerResponse = new DefaultHttpResponse(HttpVersion.HTTP_1_0, HttpResponseStatus.INTERNAL_SERVER_ERROR); try { internalServerResponse.setContent(ChannelBuffers.wrappedBuffer(("Uncaught exception!\n" + error.getMessage()).getBytes("UTF-8"))); } catch (UnsupportedEncodingException ignored) {} channel.write(internalServerResponse).addListener(ChannelFutureListener.CLOSE); } else { channel.close(); } } }
private void handleMetaRequest(ChannelHandlerContext ctx, HttpRequest request, final PullServerParams params) throws IOException, ExecutionException { final List<String> jsonMetas; try { jsonMetas = PullServerUtil.getJsonMeta(conf, lDirAlloc, localFS, params, gson, indexReaderCache, lowCacheHitCheckThreshold); } catch (FileNotFoundException e) { sendError(ctx, e.getMessage(), HttpResponseStatus.NO_CONTENT); return; } catch (IOException | IllegalArgumentException e) { // IOException, EOFException, IllegalArgumentException sendError(ctx, e.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (ExecutionException e) { // There are some problems in index cache throw new TajoInternalError(e.getCause()); } HttpResponse response = new DefaultHttpResponse(HTTP_1_1, HttpResponseStatus.OK); response.setContent(ChannelBuffers.copiedBuffer(gson.toJson(jsonMetas), CharsetUtil.UTF_8)); response.setHeader(Names.CONTENT_TYPE, "application/json; charset=UTF-8"); HttpHeaders.setContentLength(response, response.getContent().readableBytes()); if (HttpHeaders.isKeepAlive(request)) { response.setHeader(Names.CONNECTION, Values.KEEP_ALIVE); } ChannelFuture writeFuture = ctx.getChannel().write(response); // Decide whether to close the connection or not. if (!HttpHeaders.isKeepAlive(request)) { // Close the connection when the whole content is written out. writeFuture.addListener(ChannelFutureListener.CLOSE); } }
@Override public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception { final Channel channel = ctx.getChannel(); if (e instanceof ClosedChannelException || channel == null || !channel.isOpen()) { log.debug("Not writing any response, channel is already closed.", e.getCause()); return; } log.error("Uncaught exception during jersey resource handling", e.getCause()); final HttpRequest request = (HttpRequest) ctx.getAttachment(); final HttpVersion protocolVersion; if (request != null && request.getProtocolVersion() != null) { protocolVersion = request.getProtocolVersion(); } else { protocolVersion = HttpVersion.HTTP_1_0; } final DefaultHttpResponse response = new DefaultHttpResponse(protocolVersion, HttpResponseStatus.INTERNAL_SERVER_ERROR); final ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); new ChannelBufferOutputStream(buffer).writeBytes(e.toString()); response.setContent(buffer); final ChannelFuture channelFuture = channel.write(response); if ((protocolVersion == HttpVersion.HTTP_1_0) || request == null || HttpHeaders.getHeader(request, HttpHeaders.Names.CONNECTION).equalsIgnoreCase("close")) { channelFuture.addListener(ChannelFutureListener.CLOSE); } }
@Override public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception { org.jboss.netty.handler.codec.http.HttpRequest nettyRequest = (org.jboss.netty.handler.codec.http.HttpRequest) e.getMessage(); // convert request to our internal request Map<String,List<String>> headers = new HashMap<String,List<String>>(); for (String headerName : nettyRequest.getHeaderNames()) { headers.put(headerName,nettyRequest.getHeaders(headerName)); } // see if we have a body byte[] content = null; if(nettyRequest.getContent().hasArray() && nettyRequest.getContent().array().length > 0) { content = nettyRequest.getContent().array(); } else if(nettyRequest.getContent().readableBytes() > 0) { // netty content not backed by array, need to copy content = new byte[nettyRequest.getContent().readableBytes()]; nettyRequest.getContent().readBytes(content); } HttpRequest request = new HttpRequest(nettyRequest.getMethod().getName(),new URI(nettyRequest.getUri()).getPath(),headers,content); // create a temp actor to handle the response ActorRef replyActor = actorSystem.tempActorOf(HttpServiceResponseHandler.class, new HttpServiceResponseHandler.State(ctx.getChannel())); // put the actor in the attachment to propagate disconnects ctx.setAttachment(replyActor); // async handling if(!httpService.doDispatch(request,replyActor)) { // send 404 ctx.getChannel().write(new DefaultHttpResponse(HttpVersion.HTTP_1_1,HttpResponseStatus.NOT_FOUND)).addListener(ChannelFutureListener.CLOSE); actorSystem.stop(replyActor); } }