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); }
@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 static void forbidden(final ChannelHandlerContext ctx, final HttpRequest request) { ctx.getChannel().write(new DefaultHttpResponse(request.getProtocolVersion(), FORBIDDEN)) .addListener(ChannelFutureListener.CLOSE); }
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 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); }
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 _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; }
@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);
/** * 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(); } }); }
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 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(); } } }
@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 sendResponse(RestResponse response) { boolean http10 = nettyRequest.getProtocolVersion().equals(HttpVersion.HTTP_1_0); boolean close = HttpHeaders.Values.CLOSE.equalsIgnoreCase(nettyRequest.headers().get(HttpHeaders.Names.CONNECTION)) || (http10 && !HttpHeaders.Values.KEEP_ALIVE.equalsIgnoreCase(nettyRequest.headers().get(HttpHeaders.Names.CONNECTION))); org.jboss.netty.handler.codec.http.HttpResponse resp; if (http10) { resp = new DefaultHttpResponse(HttpVersion.HTTP_1_0, status); if (!close) { resp.headers().add(HttpHeaders.Names.CONNECTION, "Keep-Alive"); resp = new DefaultHttpResponse(HttpVersion.HTTP_1_1, status); resp.headers().add("Access-Control-Allow-Origin", transport.settings().get("http.cors.allow-origin", "*")); resp.headers().add("Access-Control-Max-Age", transport.settings().getAsInt("http.cors.max-age", 1728000)); callbackBytes.bytes[callbackBytes.length] = '('; callbackBytes.length++; buffer = ChannelBuffers.wrappedBuffer( future.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); } }
@Override public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception { if (e.getMessage() instanceof HttpRequest) { HttpRequest request = (HttpRequest)e.getMessage(); String originHeader = request.getHeader("Origin"); if (originHeader != null) origin = originHeader; corsHeaders = request.getHeader("Access-Control-Request-Headers"); if (request.getMethod().equals(HttpMethod.OPTIONS)) { HttpResponse response = new DefaultHttpResponse(request.getProtocolVersion(), HttpResponseStatus.NO_CONTENT); response.setHeader(HttpHeaders.Names.CONTENT_TYPE, "text/plain; charset=UTF-8"); response.setHeader(HttpHeaders.Names.CACHE_CONTROL, "max-age=31536000, public"); response.setHeader("Access-Control-Max-Age", "31536000"); // FIXME: Dirty, handle per transport? if (request.getUri().contains("/xhr")) { response.setHeader("Access-Control-Allow-Methods", "OPTIONS, POST"); } else { response.setHeader("Access-Control-Allow-Methods", "OPTIONS, GET"); } response.setHeader("Access-Control-Allow-Headers", "Content-Type"); response.setHeader("Access-Control-Allow-Credentials", "true"); response.setHeader(HttpHeaders.Names.EXPIRES, "FIXME"); // FIXME: Fix this response.setHeader(HttpHeaders.Names.SET_COOKIE, "JSESSIONID=dummy; path=/"); ctx.getChannel().write(response).addListener(ChannelFutureListener.CLOSE); return; } } super.messageReceived(ctx, e); }
throws Exception { HttpRequest request = (HttpRequest) evt.getMessage(); if (request.getMethod() != GET) { sendError(ctx, METHOD_NOT_ALLOWED); return; request.headers().get(ShuffleHeader.HTTP_HEADER_NAME)) || !ShuffleHeader.DEFAULT_HTTP_HEADER_VERSION.equals( request.headers().get(ShuffleHeader.HTTP_HEADER_VERSION))) { sendError(ctx, "Incompatible shuffle request version", BAD_REQUEST); return; HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK); try { verifyRequest(jobId, ctx, request, response, ChannelPipeline pipeline = ch.getPipeline(); TimeoutHandler timeoutHandler = (TimeoutHandler)pipeline.get(TIMEOUT_HANDLER); timeoutHandler.setEnabledTimeout(false); return; ch.write(response);
@Override public void messageReceived(final ChannelHandlerContext ctx, final MessageEvent evt) throws Exception { final HttpRequest req = (HttpRequest)evt.getMessage(); s_logger.warning("Method " + req.getMethod() + " is not supported"); final HttpResponse response = new DefaultHttpResponse(RtspVersions.RTSP_1_0, RtspResponseStatuses.METHOD_NOT_VALID); ctx.getChannel().write(response); } }