private static void sendHttpResponse(ChannelHandlerContext ctx, HttpRequest req, HttpResponse res) { ChannelFuture f = ctx.getChannel().write(res); if (!isKeepAlive(req) || res.getStatus().getCode() != 200) { f.addListener(ChannelFutureListener.CLOSE); } }
@Override public ClientResponse<RetryResponseHolder<Intermediate>> handleResponse(HttpResponse httpResponse) { LOG.debug("UnauthorizedResponseHandler - Got response status {}", httpResponse.getStatus()); if (httpResponse.getStatus().equals(HttpResponseStatus.UNAUTHORIZED)) { // Drain the buffer //noinspection ResultOfMethodCallIgnored httpResponse.getContent().toString(); return ClientResponse.unfinished(RetryResponseHolder.retry()); } else { return wrap(httpResponseHandler.handleResponse(httpResponse)); } }
@Override protected void encodeInitialLine(ChannelBuffer buf, HttpMessage message) throws Exception { HttpResponse response = (HttpResponse) message; buf.writeBytes(response.getProtocolVersion().toString().getBytes("ASCII")); buf.writeByte((byte) ' '); buf.writeBytes(String.valueOf(response.getStatus().getCode()).getBytes("ASCII")); buf.writeByte((byte) ' '); buf.writeBytes(String.valueOf(response.getStatus().getReasonPhrase()).getBytes("ASCII")); buf.writeByte((byte) '\r'); buf.writeByte((byte) '\n'); } }
@Override public ClientResponse<InputStream> handleResponse(HttpResponse response, TrafficCop trafficCop) { returnCode.set(response.getStatus().getCode()); reasonString.set(response.getStatus().getReasonPhrase()); return super.handleResponse(response, trafficCop); } };
/** * Returns the {@link HttpResponseStatus} represented by the HTTP response status header. */ public static HttpResponseStatus getStatus(int spdyVersion, SpdyHeadersFrame frame) { try { String status = frame.headers().get(HttpNames.STATUS); int space = status.indexOf(' '); if (space == -1) { return HttpResponseStatus.valueOf(Integer.parseInt(status)); } else { int code = Integer.parseInt(status.substring(0, space)); String reasonPhrase = status.substring(space + 1); HttpResponseStatus responseStatus = HttpResponseStatus.valueOf(code); if (responseStatus.getReasonPhrase().equals(reasonPhrase)) { return responseStatus; } else { return new HttpResponseStatus(code, reasonPhrase); } } } catch (Exception e) { return null; } }
private void sendHttpResponse(ChannelHandlerContext ctx, HttpRequest req, HttpResponse res) { // Generate an error page if response status code is not OK (200). if (res.getStatus().getCode() != HttpResponseStatus.OK.getCode()) { res.setContent( ChannelBuffers.copiedBuffer( res.getStatus().toString(), CharsetUtil.UTF_8)); setContentLength(res, res.getContent().readableBytes()); } // Send the response and close the connection if necessary. ChannelFuture f = ctx.getChannel().write(res); if (!isKeepAlive(req) || res.getStatus().getCode() != HttpResponseStatus.OK.getCode()) { f.addListener(ChannelFutureListener.CLOSE); } } }
protected void sendError(ChannelHandlerContext ctx, HttpResponseStatus status) { HttpResponse response = new DefaultHttpResponse(HTTP_1_1, status); response.setHeader(CONTENT_TYPE, "text/plain; charset=UTF-8"); response.setContent(ChannelBuffers.copiedBuffer( "Failure: " + status.toString() + "\r\n", CharsetUtil.UTF_8)); // Close the connection as soon as the error message is sent. ctx.getChannel().write(response).addListener(ChannelFutureListener.CLOSE); } }
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 all error responses to the client. * * TODO REST-Server 1. collect error stats * * @param messageEvent - for retrieving the channel details * @param status - error code * @param message - error message */ public static void writeErrorResponse(MessageEvent messageEvent, HttpResponseStatus status, String message) { // Create the Response object HttpResponse response = new DefaultHttpResponse(HTTP_1_1, status); response.setHeader(CONTENT_TYPE, "text/plain; charset=UTF-8"); response.setContent(ChannelBuffers.copiedBuffer("Failure: " + status.toString() + ". " + message + "\r\n", CharsetUtil.UTF_8)); response.setHeader(CONTENT_LENGTH, response.getContent().readableBytes()); // Write the response to the Netty Channel messageEvent.getChannel().write(response); } }
@Override public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception { Object msg = e.getMessage(); if (msg instanceof HttpResponse && ((HttpResponse) msg).getStatus().getCode() == 100) { ctx.sendUpstream(e); } else if (msg instanceof HttpMessage) { HttpMessage m = (HttpMessage) msg; String contentEncoding = m.headers().get(HttpHeaders.Names.CONTENT_ENCODING); if (contentEncoding != null) { contentEncoding = contentEncoding.trim(); boolean hasContent = m.isChunked() || m.getContent().readable(); if (hasContent && (decoder = newContentDecoder(contentEncoding)) != null) { m.headers().remove(HttpHeaders.Names.CONTENT_ENCODING); } else { m.headers().set(HttpHeaders.Names.CONTENT_ENCODING, targetContentEncoding); ChannelBuffer content = m.getContent(); content = ChannelBuffers.wrappedBuffer( decode(content), finishDecode()); m.headers().set( HttpHeaders.Names.CONTENT_LENGTH, Integer.toString(content.readableBytes()));
HttpResponse nettyResponse = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.valueOf(response.status)); if (exposePlayServer) { nettyResponse.headers().set(SERVER, signature); nettyResponse = addEtag(nettyRequest, nettyResponse, localFile); if (nettyResponse.getStatus().equals(HttpResponseStatus.NOT_MODIFIED)) { Channel ch = e.getChannel(); ChannelFuture writeFuture = ch.write(nettyResponse); if (!keepAlive) { Logger.error(ez, "serveStatic for request %s", request.method + " " + request.url); try { HttpResponse errorResponse = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.INTERNAL_SERVER_ERROR); String errorHtml = "Internal Error (check logs)"; byte[] bytes = errorHtml.getBytes(response.encoding); ChannelBuffer buf = ChannelBuffers.copiedBuffer(bytes); setContentLength(nettyResponse, bytes.length); errorResponse.setContent(buf); ChannelFuture future = ctx.getChannel().write(errorResponse); future.addListener(ChannelFutureListener.CLOSE); } catch (Exception ex) {
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()); }
public void messageReceived(ChannelHandlerContext ctx, MessageEvent event, HttpRequest request) throws Exception { boolean keepAlive = org.jboss.netty.handler.codec.http.HttpHeaders.isKeepAlive(request); HttpResponseStatus status = HttpResponseStatus.valueOf(nettyResponse.getStatus()); HttpResponse response = new DefaultHttpResponse(HTTP_1_1, status); .createHeaderDelegate(value.getClass()); if (delegate != null) { response.addHeader(key, delegate.toString(value)); } else { response.setHeader(key, value.toString()); response.setContent(nettyResponse.getBuffer()); response.setHeader(Names.CONTENT_LENGTH, response.getContent().readableBytes()); response.setHeader(Names.CONNECTION, Values.KEEP_ALIVE); ChannelFuture future = event.getChannel().write(response);
private void sendError(final ChannelHandlerContext ctx, final HttpResponseStatus status) { final HttpResponse response = new DefaultHttpResponse(HTTP_1_1, status); setHeader(response, CONTENT_TYPE, "text/plain; charset=UTF-8"); response.setContent(ChannelBuffers.copiedBuffer( "Failure: " + status.toString() + "\r\n", CharsetUtil.UTF_8)); // Close the connection as soon as the error message is sent. ctx.getChannel().write(response).addListener(ChannelFutureListener.CLOSE); } }
NettyHttpResponse nettyResponse = (NettyHttpResponse) msg; HttpResponseStatus status = HttpResponseStatus.valueOf(nettyResponse.getStatus()); HttpResponse response = new DefaultHttpResponse(HTTP_1_1, status); if (delegate != null) response.headers().add(key, delegate.toString(value)); response.headers().add(key, value.toString()); response.setContent(buffer); response.headers() .set(Names.CONTENT_LENGTH, buffer.readableBytes()) .set(Names.CONNECTION, Values.KEEP_ALIVE);
logger.debug(String.format("Channel %s WS Version 00 server handshake", channel.getId())); 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); HttpResponse res = new DefaultHttpResponse(HTTP_1_1, new HttpResponseStatus(101, isHixie76 ? "WebSocket Protocol Handshake" : "Web Socket Protocol Handshake")); res.headers().add(Names.UPGRADE, WEBSOCKET); res.headers().add(CONNECTION, Values.UPGRADE); 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); 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));
private void sendError(String err, HttpResponseStatus status, Channel ch) { HttpResponse resp = new DefaultHttpResponse(HTTP_1_1, status); resp.setChunked(false); if (status.getCode() == METHOD_NOT_ALLOWED.getCode()) { // SockJS requires this resp.setHeader("allow", "GET"); } if (err != null) { ChannelBuffer buff = ChannelBuffers.copiedBuffer(err.getBytes(Charset.forName("UTF-8"))); resp.setHeader("Content-Length", err.length()); resp.setContent(buff); } else { resp.setHeader(HttpHeaders.Names.CONTENT_LENGTH, "0"); } ch.write(resp); }
@Override public void sendError(int status, String message) throws IOException { if (committed) { throw new IllegalStateException(); } HttpResponseStatus responseStatus = null; if (message != null) { responseStatus = new HttpResponseStatus(status, message); } else { responseStatus = HttpResponseStatus.valueOf(status); } DefaultHttpResponse response = new DefaultHttpResponse(HTTP_1_1, responseStatus); if (keepAlive) { // Add keep alive and content length if needed response.headers() .add(Names.CONNECTION, Values.KEEP_ALIVE) .add(Names.CONTENT_LENGTH, 0); } channel.write(response); committed = true; }
public void handleHttpRequest(ChannelHandlerContext context, HttpRequest request) { // request must be valid http GET request if (isNotHttpGetRequest(request)) { sendHttpResponse(context, request, new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.FORBIDDEN)); return; } try { HttpResponse response = processHandshake(request); if (!response.getStatus().equals(HttpResponseStatus.SWITCHING_PROTOCOLS)) { // sending error http response sendHttpResponse(context, request, response); return; } initializeWebsocketConnector(context, request, response); replaceListeners(context); } catch (NoSuchAlgorithmException e) { context.getChannel().close(); } }
@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); }