/** * Create a copy of this HTTP request, replacing its requestLine with the provided one. * * @param requestLine to replace * @return copy of this HTTP message with the provided requestLine */ public RawHttpRequest withRequestLine(RequestLine requestLine) { return new RawHttpRequest(requestLine, getHeaders(), getBody().orElse(null), getSenderAddress().orElse(null)); }
/** * Parses the HTTP request contained in the given file. * * @param file containing a HTTP request * @return a parsed HTTP request object * @throws InvalidHttpRequest if the request is invalid * @throws IOException if a problem occurs reading the file */ public final RawHttpRequest parseRequest(File file) throws IOException { try (InputStream stream = Files.newInputStream(file.toPath())) { return parseRequest(stream).eagerly(); } }
@Override public void logRequest(RawHttpRequest request, RawHttpResponse<?> response) { executor.submit(() -> { if (request.getSenderAddress().isPresent()) { InetAddress senderAddress = request.getSenderAddress().get(); System.out.print(senderAddress.getHostAddress() + " "); } Long bytes = response.getBody() .map(b -> b.getLengthIfKnown().orElse(-1L)) .orElse(-1L); System.out.println("[" + LocalDateTime.now().format(dateFormat) + "] \"" + request.getStartLine() + "\" " + response.getStatusCode() + " " + bytes); }); }
@Override public RawHttpRequest withBody(HttpMessageBody body) { return new RawHttpRequest(requestLine, body.headersFrom(getHeaders()), body.toBodyReader(), getSenderAddress().orElse(null)); }
public RawHttpResponse<CloseableHttpResponse> send(RawHttpRequest request) throws IOException { RequestBuilder builder = RequestBuilder.create(request.getMethod()); builder.setUri(request.getUri()); builder.setVersion(toProtocolVersion(request.getStartLine().getHttpVersion())); request.getHeaders().getHeaderNames().forEach((name) -> request.getHeaders().get(name).forEach(value -> builder.addHeader(new BasicHeader(name, value)))); request.getBody().ifPresent(b -> builder.setEntity(new InputStreamEntity(b.asRawStream()))); CloseableHttpResponse response = httpClient.execute(builder.build()); RawHttpHeaders headers = readHeaders(response); StatusLine statusLine = adaptStatus(response.getStatusLine()); @Nullable LazyBodyReader body; if (response.getEntity() != null) { FramedBody framedBody = http.getFramedBody(statusLine, headers); body = new LazyBodyReader(framedBody, response.getEntity().getContent()); } else { body = null; } return new RawHttpResponse<>(response, request, statusLine, headers, body); }
@Nullable EagerBodyReader bodyReader = request.getBody().isPresent() ? request.getBody().get().eager() : null; .orElse(emptyRawHttpHeaders()); if (trailingHeaders.isEmpty()) { headers = request.getHeaders(); } else { headers = RawHttpHeaders.newBuilder(request.getHeaders()) .merge(trailingHeaders) .build(); headers = request.getHeaders(); return new EagerHttpRequest(request.getStartLine(), headers, bodyReader, request.getSenderAddress().orElse(null));
@Override public Optional<RawHttpResponse<?>> route(RawHttpRequest request) { final Optional<RawHttpResponse<?>> response; if (request.getMethod().equals("GET")) { String path = request.getStartLine().getUri() .normalize().getPath() .replaceAll(DIR_BACK_PATTERN, ""); // provide the index.html file at the root path if (path.isEmpty() || path.equals("/")) { path = "index.html"; } Optional<FileResult> resource = fileLocator.find(path, request.getHeaders().get("Accept")); response = resource.map(fileResult -> HttpResponses.getOkResponse(request.getStartLine().getHttpVersion()) .withHeaders(fileResult.contentTypeHeader) .withBody(new FileBody(fileResult.file))); } else { response = Optional.of(HttpResponses.getMethodNotAllowedResponse(request.getStartLine().getHttpVersion())); } return response; }
@Test public void replacingBodyWithChunkedEncodedMessage() throws IOException { InputStream stream = new ByteArrayInputStream("Hello RawHTTTP".getBytes()); int chunkSize = 4; RawHttp http = new RawHttp(); RawHttpRequest request = http.parseRequest("POST http://example.com/hello"); RawHttpRequest requestWithBody = request.withBody( new ChunkedBody(stream, "text/plain", chunkSize)); System.out.println(requestWithBody.eagerly()); }
client.getInputStream(), ((InetSocketAddress) client.getRemoteSocketAddress()).getAddress()); HttpVersion httpVersion = request.getStartLine().getHttpVersion(); Optional<String> connectionOption = request.getHeaders().getFirst("Connection");
@Override public RawHttpResponse<Void> send(RawHttpRequest request) throws IOException { Socket socket; try { socket = options.getSocket(request.getUri()); } catch (RuntimeException e) { Throwable cause = e.getCause(); if (cause instanceof IOException) { throw (IOException) cause; } throw e; } OutputStream outputStream = socket.getOutputStream(); options.getExecutorService().submit(() -> { try { request.writeTo(outputStream); } catch (IOException e) { e.printStackTrace(); } }); return options.onResponse(socket, request.getUri(), rawHttp.parseResponse(socket.getInputStream())); }
request.writeTo(socket.getOutputStream()); request.getHeaders().getFirst("Accept").orElse("")); request.getHeaders().getHeaderNames());
@Test public void goingRawWithoutFancyClient() throws IOException { RawHttp rawHttp = new RawHttp(); RawHttpRequest request = rawHttp.parseRequest(String.format("GET localhost:%d/hello HTTP/1.0", PORT)); Socket socket = new Socket("localhost", PORT); request.writeTo(socket.getOutputStream()); EagerHttpResponse<?> response = rawHttp.parseResponse(socket.getInputStream()).eagerly(); assertThat(response.getStatusCode(), is(200)); assertThat(response.getBody().map(EagerBodyReader::toString) .orElseThrow(() -> new RuntimeException("No body")), equalTo("Hello")); }
@Override public Optional<EagerBodyReader> getBody() { Optional<? extends BodyReader> body = super.getBody(); return body.map(b -> (EagerBodyReader) b); }
@SuppressWarnings("unchecked") private RawHttpResponse<?> route(RawHttpRequest request) throws IOException { RawHttpResponse<Void> response; try { response = router.route(request).map(res -> (RawHttpResponse<Void>) res) .orElseGet(() -> options.notFoundResponse(request).orElseGet(() -> HttpResponses.getNotFoundResponse(request.getStartLine().getHttpVersion()))); } catch (Exception e) { e.printStackTrace(); response = options.serverErrorResponse(request).orElseGet(() -> HttpResponses.getServerErrorResponse(request.getStartLine().getHttpVersion())); } return options.onResponse(request, response); }
RawHttpRequest request = http.parseRequest(client.getInputStream()); System.out.println("REQUEST:\n" + request); if (request.getUri().getPath().equals("/saysomething")) { http.parseResponse("HTTP/1.1 200 OK\n" + "Content-Type: text/plain\n" +
.withBody(new StreamedChunkedBody(sender.getChunkStream())));
/** * Parses the HTTP request produced by the given stream. * * @param inputStream producing a HTTP request * @param senderAddress the address of the request sender, if known * @return a parsed HTTP request object * @throws InvalidHttpRequest if the request is invalid * @throws IOException if a problem occurs accessing the stream */ public RawHttpRequest parseRequest(InputStream inputStream, @Nullable InetAddress senderAddress) throws IOException { RequestLine requestLine = metadataParser.parseRequestLine(inputStream); RawHttpHeaders originalHeaders = metadataParser.parseHeaders(inputStream, (message, lineNumber) -> // add 1 to the line number to correct for the start-line new InvalidHttpRequest(message, lineNumber + 1)); RawHttpHeaders.Builder modifiableHeaders = RawHttpHeaders.newBuilder(originalHeaders); // do a little cleanup to make sure the request is actually valid requestLine = verifyHost(requestLine, modifiableHeaders); RawHttpHeaders headers = modifiableHeaders.build(); @Nullable BodyReader bodyReader = requestHasBody(headers) ? createBodyReader(inputStream, requestLine, headers) : null; return new RawHttpRequest(requestLine, headers, bodyReader, senderAddress); }
@Nullable EagerBodyReader bodyReader = request.getBody().isPresent() ? request.getBody().get().eager() : null; .orElse(emptyRawHttpHeaders()); if (trailingHeaders.isEmpty()) { headers = request.getHeaders(); } else { headers = RawHttpHeaders.newBuilder(request.getHeaders()) .merge(trailingHeaders) .build(); headers = request.getHeaders(); return new EagerHttpRequest(request.getStartLine(), headers, bodyReader, request.getSenderAddress().orElse(null));
@Override public RawHttpRequest withBody(HttpMessageBody body) { return new RawHttpRequest(requestLine, body.headersFrom(getHeaders()), body.toBodyReader(), getSenderAddress().orElse(null)); }