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); new QueryStringDecoder(request.getUri()).getParameters(); final List<String> keepAliveList = q.get("keepAlive"); boolean keepAliveParam = false; final List<String> dagIdQ = q.get("dag"); if (LOG.isDebugEnabled()) { LOG.debug("RECV: " + request.getUri() + "\n mapId: " + mapIds + "\n reduceId: " + reduceQ + return; final String reqUri = request.getUri(); if (null == reqUri) { return;
if(!readingChunks) { HttpRequest request = this.request = (HttpRequest) messageEvent.getMessage(); String requestURI = this.request.getUri(); if (logger.isDebugEnabled()) { logger.debug("Admin Request URI: " + requestURI); if(request.isChunked()) { readingChunks = true; } else { storeList = Lists.newArrayList(storeArray); HttpMethod httpMethod = request.getMethod(); if(httpMethod.equals(HttpMethod.GET)) { response = handleGet(storeList); } else if(httpMethod.equals(HttpMethod.POST)) { Map<String, Properties> configsToPut = Maps.newHashMap(); ChannelBuffer content = this.request.getContent(); if(content != null) { byte[] postBody = new byte[content.capacity()]; content.readBytes(postBody); configsToPut = ClientConfigUtil.readMultipleClientConfigAvro(new String(postBody)); "Unsupported namespace. Only /" + STORE_OPS_NAMESPACE + "/ is supported."); messageEvent.getChannel().write(response);
final String hostKey = getPoolKey(url); final ResourceContainer<ChannelFuture> channelResourceContainer = pool.take(hostKey); final ChannelFuture channelFuture = channelResourceContainer.get().awaitUninterruptibly(); if (!channelFuture.isSuccess()) { channelFuture.getCause() channel.setReadable(true); httpRequest.headers().add(HttpHeaders.Names.HOST, getHost(url)); httpRequest.headers().set(HttpHeaders.Names.ACCEPT_ENCODING, compressionCodec.getEncodingString()); httpRequest.headers().add(key, obj); httpRequest.setContent(request.getContent()); channel.getPipeline().addLast( READ_TIMEOUT_HANDLER_NAME, new ReadTimeoutHandler(timer, readTimeout, TimeUnit.MILLISECONDS) channel.getPipeline().addLast( LAST_HANDLER_NAME, new SimpleChannelUpstreamHandler()
@Override protected void encodeInitialLine(ChannelBuffer buf, HttpMessage message) throws Exception { HttpRequest request = (HttpRequest) message; buf.writeBytes(request.getMethod().toString().getBytes("ASCII")); buf.writeByte((byte) ' '); buf.writeBytes(request.getUri().getBytes("UTF-8")); buf.writeByte((byte) ' '); buf.writeBytes(request.getProtocolVersion().toString().getBytes("ASCII")); buf.writeByte((byte) '\r'); buf.writeByte((byte) '\n'); } }
/** * * @param factory the factory used to create InterfaceHttpData * @param request the request to decode * @param charset the charset to use as default * @throws NullPointerException for request or charset or factory * @throws ErrorDataDecoderException if the default charset was wrong when decoding or other errors */ public HttpPostStandardRequestDecoder(HttpDataFactory factory, HttpRequest request, Charset charset) throws ErrorDataDecoderException { if (factory == null) { throw new NullPointerException("factory"); } if (request == null) { throw new NullPointerException("request"); } if (charset == null) { throw new NullPointerException("charset"); } this.request = request; this.charset = charset; this.factory = factory; if (!this.request.isChunked()) { undecodedChunk = this.request.getContent(); isLastChunk = true; parseBody(); } }
@Override protected Object encode(ChannelHandlerContext ctx, Channel channel, Object msg) throws Exception { if (msg instanceof HttpRequest && !done) { queue.offer(((HttpRequest) msg).getMethod()); } Object obj = super.encode(ctx, channel, msg); if (failOnMissingResponse) { // check if the request is chunked if so do not increment if (msg instanceof HttpRequest && !((HttpRequest) msg).isChunked()) { requestResponseCounter.incrementAndGet(); } else if (msg instanceof HttpChunk && ((HttpChunk) msg).isLast()) { // increment as its the last chunk requestResponseCounter.incrementAndGet(); } } return obj; } }
String key = WebSocketUtil.base64(ChannelBuffers.wrappedBuffer(nonce)); ChannelBuffer sha1 = WebSocketUtil.sha1(ChannelBuffers.copiedBuffer(acceptSeed, CharsetUtil.US_ASCII)); expectedChallengeResponseString = WebSocketUtil.base64(sha1); request.headers().add(Names.UPGRADE, Values.WEBSOCKET.toLowerCase()); request.headers().add(Names.CONNECTION, Values.UPGRADE); request.headers().add(Names.SEC_WEBSOCKET_KEY, key); request.headers().add(Names.HOST, wsURL.getHost()); request.headers().add(Names.SEC_WEBSOCKET_ORIGIN, originValue); request.headers().add(Names.SEC_WEBSOCKET_PROTOCOL, expectedSubprotocol); request.headers().add(Names.SEC_WEBSOCKET_VERSION, "7"); request.headers().add(e.getKey(), e.getValue()); ChannelFuture future = channel.write(request); future.addListener(new ChannelFutureListener() {
@Override public void sendError(HttpResponseStatus status, Throwable throwable) { // Decide whether to close the connection or not. boolean http10 = request.getProtocolVersion().equals(HttpVersion.HTTP_1_0); boolean close = HttpHeaders.Values.CLOSE.equalsIgnoreCase(request.getHeader(HttpHeaders.Names.CONNECTION)) || (http10 && !HttpHeaders.Values.KEEP_ALIVE.equalsIgnoreCase(request.getHeader(HttpHeaders.Names.CONNECTION))); // Build the response object. HttpResponse resp = null; if (http10) { resp = new DefaultHttpResponse(HttpVersion.HTTP_1_0, status); if (!close) { resp.addHeader(HttpHeaders.Names.CONNECTION, "Keep-Alive"); } } else { resp = new DefaultHttpResponse(HttpVersion.HTTP_1_1, status); } String cause = getErrorHtml(status, throwable); byte[] errorMessage = cause.getBytes(Charset.forName("UTF-8")); ChannelBuffer buf = ChannelBuffers.wrappedBuffer(errorMessage); resp.setContent(buf); resp.setHeader(HttpHeaders.Names.CONTENT_TYPE, "text/html"); resp.setHeader(HttpHeaders.Names.CONTENT_ENCODING, "UTF-8"); resp.setHeader(HttpHeaders.Names.CONTENT_LENGTH, buf.readableBytes()); // Write the response. ChannelFuture future = channel.write(resp); // Close the connection after the write operation is done if necessary. if (close) { future.addListener(ChannelFutureListener.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);
@Override public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception { ChannelBuffer input; HttpRequest httpRequest = null; if (e.getMessage() instanceof HttpRequest) { httpRequest = ((HttpRequest)e.getMessage()); input = httpRequest.getContent(); } else { input = (ChannelBuffer)e.getMessage(); } ChannelBuffer output = ChannelBuffers.dynamicBuffer(responseSize); TProtocol protocol = protocolFactory.getProtocol(new TNettyChannelBuffer(input, output)); processor.process(protocol, protocol); if (httpRequest != null) { HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK); response.setHeader("Content-Length", output.readableBytes()); response.setContent(output); ChannelFuture future = e.getChannel().write(response); if (!HttpHeaders.isKeepAlive(httpRequest)) { future.addListener(ChannelFutureListener.CLOSE); } } else { e.getChannel().write(output); } }
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); }
System.arraycopy(number2Array, 0, challenge, 4, 4); System.arraycopy(key3, 0, challenge, 8, 8); expectedChallengeResponseBytes = WebSocketUtil.md5(ChannelBuffers.wrappedBuffer(challenge)); request.headers().add(Names.UPGRADE, Values.WEBSOCKET); request.headers().add(Names.CONNECTION, Values.UPGRADE); request.headers().add(Names.HOST, wsURL.getHost()); request.headers().add(Names.ORIGIN, originValue); request.headers().add(Names.SEC_WEBSOCKET_KEY1, key1); request.headers().add(Names.SEC_WEBSOCKET_KEY2, key2); String expectedSubprotocol = getExpectedSubprotocol(); if (expectedSubprotocol != null && expectedSubprotocol.length() != 0) { request.headers().add(Names.SEC_WEBSOCKET_PROTOCOL, expectedSubprotocol); request.headers().add(e.getKey(), e.getValue()); request.headers().set(Names.CONTENT_LENGTH, key3.length); request.setContent(ChannelBuffers.copiedBuffer(key3)); ChannelFuture future = channel.write(request); future.addListener(new ChannelFutureListener() { public void operationComplete(ChannelFuture future) { ChannelPipeline p = future.getChannel().getPipeline();
@Override public void prepareHandshakeResponse(NettyWebSocketConnection webSocketConnection) { webSocketConnection.setVersion("HIXIE-76"); res.setStatus(new HttpResponseStatus(101, "Web Socket Protocol Handshake")); res.addHeader(UPGRADE, WEBSOCKET); res.addHeader(CONNECTION, UPGRADE); res.addHeader(SEC_WEBSOCKET_ORIGIN, req.getHeader(ORIGIN)); res.addHeader(SEC_WEBSOCKET_LOCATION, getWebSocketLocation(req)); 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); ChannelBuffer output = ChannelBuffers.wrappedBuffer(MD5.digest(input.array())); res.setContent(output); }
/** Handle conditional connection close depending on keep-alive */ private void writeResponse(Channel channel, HttpRequest request, HttpResponse response) { response.setHeader(CONTENT_LENGTH, response.getContent().readableBytes()); boolean hasKeepAliveHeader = KEEP_ALIVE.equalsIgnoreCase(request.getHeader(CONNECTION)); if (!request.getProtocolVersion().isKeepAliveDefault() && hasKeepAliveHeader) { response.setHeader(CONNECTION, KEEP_ALIVE); } ChannelFuture wf = channel.write(response); if (!HttpHeaders.isKeepAlive(request)) { wf.addListener(ChannelFutureListener.CLOSE); } }
public ChannelPipeline retrieve(HttpRequest request) throws Exception { URI uri = new URI(request.getUri()); int port = uri.getPort() == -1 ? 80 : uri.getPort(); ChannelFuture connectFuture = client.connect(new InetSocketAddress(request .getHeader(org.jboss.netty.handler.codec.http.HttpHeaders.Names.HOST), port)); //connectFuture.addListener(new ConnectOk(request)); connectFuture.awaitUninterruptibly(); if (!connectFuture.isSuccess()) { connectFuture.getCause().printStackTrace(); client.releaseExternalResources(); throw new RuntimeException(connectFuture.getCause()); } channels.add(connectFuture.getChannel()); return connectFuture.getChannel().getPipeline(); }
private static void forbidden(final ChannelHandlerContext ctx, final HttpRequest request) { ctx.getChannel().write(new DefaultHttpResponse(request.getProtocolVersion(), FORBIDDEN)) .addListener(ChannelFutureListener.CLOSE); }
@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); }
@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); } }
if (!Values.UPGRADE.equalsIgnoreCase(req.headers().get(CONNECTION)) || !WEBSOCKET.equalsIgnoreCase(req.headers().get(Names.UPGRADE))) { throw new WebSocketHandshakeException("not a WebSocket handshake request: missing upgrade"); boolean isHixie76 = req.headers().contains(SEC_WEBSOCKET_KEY1) && req.headers().contains(SEC_WEBSOCKET_KEY2); res.headers().add(SEC_WEBSOCKET_ORIGIN, req.headers().get(ORIGIN)); res.headers().add(SEC_WEBSOCKET_LOCATION, getWebSocketUrl()); String subprotocols = req.headers().get(SEC_WEBSOCKET_PROTOCOL); if (subprotocols != null) { String selectedSubprotocol = selectSubprotocol(subprotocols); String key1 = req.headers().get(SEC_WEBSOCKET_KEY1); String key2 = req.headers().get(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); res.setContent(WebSocketUtil.md5(input)); } else { res.headers().add(WEBSOCKET_ORIGIN, req.headers().get(ORIGIN)); res.headers().add(WEBSOCKET_LOCATION, getWebSocketUrl()); String protocol = req.headers().get(WEBSOCKET_PROTOCOL); if (protocol != null) { res.headers().add(WEBSOCKET_PROTOCOL, selectSubprotocol(protocol));
final HttpRequest request = (HttpRequest) e.getMessage(); if (request.getMethod() != GET) { sendError(ctx, METHOD_NOT_ALLOWED); return; final String uri = request.getUri(); if (uri.equals("/")) { final HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK); response.setStatus(MOVED_PERMANENTLY); setHeader(response, LOCATION, "/fake-stream"); writeFuture = ch.write(response); writeFuture.addListener(ChannelFutureListener.CLOSE); } else { final HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK); setHeader(response, TRANSFER_ENCODING, "chunked"); response.setChunked(true); final Channel ch = e.getChannel(); ch.write(response); ch.write(getChunkedInput());