/*
* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.incubator.http;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.net.URI;
import java.nio.ByteBuffer;
import java.nio.charset.*;
import java.nio.file.Path;
import java.time.Duration;
import java.util.Iterator;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Flow;
import java.util.function.Supplier;
/**
* Represents one HTTP request which can be sent to a server. {@code
* HttpRequest}s are built from {@code HttpRequest} {@link HttpRequest.Builder
* builder}s. {@code HttpRequest} builders are obtained
* by calling {@link HttpRequest#newBuilder(java.net.URI) HttpRequest.newBuilder}.
* A request's {@link java.net.URI}, headers and body can be set. Request bodies
* are provided through a {@link BodyProcessor} object supplied to the
* {@link Builder#DELETE(jdk.incubator.http.HttpRequest.BodyProcessor) DELETE},
* {@link Builder#POST(jdk.incubator.http.HttpRequest.BodyProcessor) POST} or
* {@link Builder#PUT(jdk.incubator.http.HttpRequest.BodyProcessor) PUT} methods.
* {@link Builder#GET() GET} does not take a body. Once all required
* parameters have been set in the builder, {@link Builder#build() } is called
* to return the {@code HttpRequest}. Builders can also be copied
* and modified multiple times in order to build multiple related requests that
* differ in some parameters.
*
* <p> Two simple, example HTTP interactions are shown below:
* <pre>
* {@code
* HttpClient client = HttpClient.newHttpClient();
*
* // GET
* HttpResponse<String> response = client.send(
* HttpRequest
* .newBuilder(new URI("http://www.foo.com/"))
* .headers("Foo", "foovalue", "Bar", "barvalue")
* .GET()
* .build(),
* BodyHandler.asString()
* );
* int statusCode = response.statusCode();
* String body = response.body();
*
* // POST
* HttpResponse<Path> response = client.send(
* HttpRequest
* .newBuilder(new URI("http://www.foo.com/"))
* .headers("Foo", "foovalue", "Bar", "barvalue")
* .POST(BodyProcessor.fromString("Hello world"))
* .build(),
* BodyHandler.asFile(Paths.get("/path"))
* );
* int statusCode = response.statusCode();
* Path body = response.body(); // should be "/path"
* }
* </pre>
* <p> The request is sent and the response obtained by calling one of the
* following methods in {@link HttpClient}.
* <ul><li>{@link HttpClient#send(HttpRequest, HttpResponse.BodyHandler)} blocks
* until the entire request has been sent and the response has been received.</li>
* <li>{@link HttpClient#sendAsync(HttpRequest,HttpResponse.BodyHandler)} sends the
* request and receives the response asynchronously. Returns immediately with a
* {@link java.util.concurrent.CompletableFuture CompletableFuture}<{@link
* HttpResponse}>.</li>
* <li>{@link HttpClient#sendAsync(HttpRequest,HttpResponse.MultiProcessor) }
* sends the request asynchronously, expecting multiple responses. This
* capability is of most relevance to HTTP/2 server push, but can be used for
* single responses (HTTP/1.1 or HTTP/2) also.</li>
* </ul>
*
* <p> Once a {@link HttpResponse} is received, the headers, response code
* and body (typically) are available. Whether the body has been read or not
* depends on the type {@code <T>} of the response body. See below.
*
* <p> See below for discussion of synchronous versus asynchronous usage.
*
* <p> <b>Request bodies</b>
*
* <p> Request bodies are sent using one of the request processor implementations
* below provided in {@link HttpRequest.BodyProcessor}, or else a custom implementation can be
* used.
* <ul>
* <li>{@link BodyProcessor#fromByteArray(byte[]) fromByteArray(byte[])} from byte array</li>
* <li>{@link BodyProcessor#fromByteArrays(Iterable) fromByteArrays(Iterable)}
* from an Iterable of byte arrays</li>
* <li>{@link BodyProcessor#fromFile(java.nio.file.Path) fromFile(Path)} from the file located
* at the given Path</li>
* <li>{@link BodyProcessor#fromString(java.lang.String) fromString(String)} from a String </li>
* <li>{@link BodyProcessor#fromInputStream(Supplier) fromInputStream}({@link Supplier}<
* {@link InputStream}>) from an InputStream obtained from a Supplier</li>
* <li>{@link BodyProcessor#noBody() } no request body is sent</li>
* </ul>
*
* <p> <b>Response bodies</b>
*
* <p>Responses bodies are handled at two levels. When sending the request,
* a response body handler is specified. This is a function ({@link HttpResponse.BodyHandler})
* which will be called with the response status code and headers, once these are received. This
* function is then expected to return a {@link HttpResponse.BodyProcessor}
* {@code <T>} which is then used to read the response body converting it
* into an instance of T. After this occurs, the response becomes
* available in a {@link HttpResponse} and {@link HttpResponse#body()} can then
* be called to obtain the body. Some implementations and examples of usage of both {@link
* HttpResponse.BodyProcessor} and {@link HttpResponse.BodyHandler}
* are provided in {@link HttpResponse}:
* <p><b>Some of the pre-defined body handlers</b><br>
* <ul>
* <li>{@link HttpResponse.BodyHandler#asByteArray() BodyHandler.asByteArray()}
* stores the body in a byte array</li>
* <li>{@link HttpResponse.BodyHandler#asString() BodyHandler.asString()}
* stores the body as a String </li>
* <li>{@link HttpResponse.BodyHandler#asFile(java.nio.file.Path)
* BodyHandler.asFile(Path)} stores the body in a named file</li>
* <li>{@link HttpResponse.BodyHandler#discard(Object) BodyHandler.discard()}
* discards the response body and returns the given value instead.</li>
* </ul>
*
* <p> <b>Multi responses</b>
*
* <p> With HTTP/2 it is possible for a server to return a main response and zero
* or more additional responses (known as server pushes) to a client-initiated
* request. These are handled using a special response processor called {@link
* HttpResponse.MultiProcessor}.
*
* <p> <b>Blocking/asynchronous behavior and thread usage</b>
*
* <p> There are two styles of request sending: <i>synchronous</i> and
* <i>asynchronous</i>. {@link HttpClient#send(HttpRequest, HttpResponse.BodyHandler) }
* blocks the calling thread until the request has been sent and the response received.
*
* <p> {@link HttpClient#sendAsync(HttpRequest, HttpResponse.BodyHandler)} is asynchronous and returns
* immediately with a {@link java.util.concurrent.CompletableFuture}<{@link
* HttpResponse}> and when this object completes (in a background thread) the
* response has been received.
*
* <p> {@link HttpClient#sendAsync(HttpRequest,HttpResponse.MultiProcessor)}
* is the variant for multi responses and is also asynchronous.
*
* <p> {@code CompletableFuture}s can be combined in different ways to declare the
* dependencies among several asynchronous tasks, while allowing for the maximum
* level of parallelism to be utilized.
*
* <p> <b>Security checks</b>
*
* <p> If a security manager is present then security checks are performed by
* the sending methods. A {@link java.net.URLPermission} or {@link java.net.SocketPermission} is required to
* access any destination origin server and proxy server utilised. {@code URLPermission}s
* should be preferred in policy files over {@code SocketPermission}s given the more
* limited scope of {@code URLPermission}. Permission is always implicitly granted to a
* system's default proxies. The {@code URLPermission} form used to access proxies uses
* a method parameter of {@code "CONNECT"} (for all kinds of proxying) and a url string
* of the form {@code "socket://host:port"} where host and port specify the proxy's
* address.
*
* <p> <b>Examples</b>
* <pre>{@code
* HttpClient client = HttpClient
* .newBuilder()
* .build();
*
* HttpRequest request = HttpRequest
* .newBuilder(new URI("http://www.foo.com/"))
* .POST(BodyProcessor.fromString("Hello world"))
* .build();
*
* HttpResponse<Path> response =
* client.send(request, BodyHandler.asFile(Paths.get("/path")));
*
* Path body = response.body();
* }</pre>
*
* <p><b>Asynchronous Example</b>
*
* <p> The above example will work asynchronously, if {@link HttpClient#sendAsync
* (HttpRequest, HttpResponse.BodyHandler) sendAsync} is used instead of
* {@link HttpClient#send(HttpRequest,HttpResponse.BodyHandler) send}
* in which case the returned object is a {@link CompletableFuture}{@code <HttpResponse>}
* instead of {@link HttpResponse}. The following example shows how multiple requests
* can be sent asynchronously. It also shows how dependent asynchronous operations
* (receiving response, and receiving response body) can be chained easily using
* one of the many methods in {@code CompletableFuture}.
* <pre>
* {@code
* // fetch a list of target URIs asynchronously and store them in Files.
*
* List<URI> targets = ...
*
* List<CompletableFuture<File>> futures = targets
* .stream()
* .map(target -> client
* .sendAsync(
* HttpRequest.newBuilder(target)
* .GET()
* .build(),
* BodyHandler.asFile(Paths.get("base", target.getPath())))
* .thenApply(response -> response.body())
* .thenApply(path -> path.toFile()))
* .collect(Collectors.toList());
*
* // all async operations waited for here
*
* CompletableFuture.allOf(futures.toArray(new CompletableFuture<?>[0]))
* .join();
*
* // all elements of futures have completed and can be examined.
* // Use File.exists() to check whether file was successfully downloaded
* }
* </pre>
* <p>
* Unless otherwise stated, {@code null} parameter values will cause methods
* of this class to throw {@code NullPointerException}.
*
* @since 9
*/
public abstract class HttpRequest {
/**
* Creates an HttpRequest.
*/
protected HttpRequest() {}
/**
* A builder of {@link HttpRequest}s. {@code HttpRequest.Builder}s are
* created by calling {@link HttpRequest#newBuilder(URI)} or {@link
* HttpRequest#newBuilder()}.
*
* <p> Each of the setter methods in this class modifies the state of the
* builder and returns <i>this</i> (ie. the same instance). The methods are
* not synchronized and should not be called from multiple threads without
* external synchronization.
* <p>Note, that not all request headers may be set by user code. Some are
* restricted for security reasons and others such as the headers relating
* to authentication, redirection and cookie management are managed by
* specific APIs rather than through directly user set headers.
*
* <p> The {@linkplain #build() build} method returns a new {@code
* HttpRequest} each time it is invoked.
*
* @since 9
*/
public abstract static class Builder {
/**
* Creates a Builder.
*/
protected Builder() {}
/**
* Sets this {@code HttpRequest}'s request {@code URI}.
*
* @param uri the request URI
* @return this request builder
* @throws IllegalArgumentException if the {@code URI} scheme is not
* supported.
*/
public abstract Builder uri(URI uri);
/**
* Request server to acknowledge request before sending request
* body. This is disabled by default. If enabled, the server is requested
* to send an error response or a {@code 100 Continue} response before the client
* sends the request body. This means the request processor for the
* request will not be invoked until this interim response is received.
*
* @param enable {@code true} if Expect continue to be sent
* @return this request builder
*/
public abstract Builder expectContinue(boolean enable);
/**
* Overrides the {@link HttpClient#version() } setting for this
* request. This sets the version requested. The corresponding
* {@link HttpResponse} should be checked for the version that was
* used.
*
* @param version the HTTP protocol version requested
* @return this request builder
*/
public abstract Builder version(HttpClient.Version version);
/**
* Adds the given name value pair to the set of headers for this request.
*
* @param name the header name
* @param value the header value
* @return this request builder
*/
public abstract Builder header(String name, String value);
// /**
// * Overrides the {@code ProxySelector} set on the request's client for this
// * request.
// *
// * @param proxy the ProxySelector to use
// * @return this request builder
// */
// public abstract Builder proxy(ProxySelector proxy);
/**
* Adds the given name value pairs to the set of headers for this
* request. The supplied {@code String}s must alternate as names and values.
*
* @param headers the list of String name value pairs
* @return this request builder
* @throws IllegalArgumentException if there is an odd number of
* parameters
*/
// TODO (spec): consider signature change
// public abstract Builder headers(java.util.Map.Entry<String,String>... headers);
public abstract Builder headers(String... headers);
/**
* Sets a timeout for this request. If the response is not received
* within the specified timeout then a {@link HttpTimeoutException} is
* thrown from {@link HttpClient#send(jdk.incubator.http.HttpRequest,
* jdk.incubator.http.HttpResponse.BodyHandler) HttpClient::send} or
* {@link HttpClient#sendAsync(jdk.incubator.http.HttpRequest,
* jdk.incubator.http.HttpResponse.BodyHandler) HttpClient::sendAsync}
* completes exceptionally with a {@code HttpTimeoutException}. The effect
* of not setting a timeout is the same as setting an infinite Duration, ie.
* block forever.
*
* @param duration
* @return this request builder
*/
public abstract Builder timeout(Duration duration);
/**
* Sets the given name value pair to the set of headers for this
* request. This overwrites any previously set values for name.
*
* @param name the header name
* @param value the header value
* @return this request builder
*/
public abstract Builder setHeader(String name, String value);
/**
* Sets the request method of this builder to GET.
*
* @return a {@code HttpRequest}
*/
public abstract Builder GET();
/**
* Sets the request method of this builder to POST and sets its
* request body processor to the given value.
*
* @param body the body processor
*
* @return a {@code HttpRequest}
*/
public abstract Builder POST(BodyProcessor body);
/**
* Sets the request method of this builder to PUT and sets its
* request body processor to the given value.
*
* @param body the body processor
*
* @return a {@code HttpRequest}
*/
public abstract Builder PUT(BodyProcessor body);
/**
* Sets the request method of this builder to DELETE and sets its
* request body processor to the given value.
*
* @param body the body processor
*
* @return a {@code HttpRequest}
*/
public abstract Builder DELETE(BodyProcessor body);
/**
* Sets the request method and request body of this builder to the
* given values.
*
* @param body the body processor
* @param method the method to use
* @return a {@code HttpRequest}
* @throws IllegalArgumentException if an unrecognized method is used
*/
public abstract Builder method(String method, BodyProcessor body);
/**
* Builds and returns a {@link HttpRequest}.
*
* @return the request
*/
public abstract HttpRequest build();
/**
* Returns an exact duplicate copy of this {@code Builder} based on current
* state. The new builder can then be modified independently of this
* builder.
*
* @return an exact copy of this Builder
*/
public abstract Builder copy();
}
/**
* Creates a {@code HttpRequest} builder.
*
* @param uri the request URI
* @return a new request builder
* @throws IllegalArgumentException if the URI scheme is not supported.
*/
public static HttpRequest.Builder newBuilder(URI uri) {
return new HttpRequestBuilderImpl(uri);
}
/**
* Creates a {@code HttpRequest} builder.
*
* @return a new request builder
*/
public static HttpRequest.Builder newBuilder() {
return new HttpRequestBuilderImpl();
}
/**
* Returns an {@code Optional} containing the {@link BodyProcessor}
* set on this request. If no {@code BodyProcessor} was set in the
* requests's builder, then the {@code Optional} is empty.
*
* @return an {@code Optional} containing this request's
* {@code BodyProcessor}
*/
public abstract Optional<BodyProcessor> bodyProcessor();
/**
* Returns the request method for this request. If not set explicitly,
* the default method for any request is "GET".
*
* @return this request's method
*/
public abstract String method();
/**
* Returns the duration for this request.
*
* @return this requests duration
*/
public abstract Duration duration();
/**
* Returns this request's {@link HttpRequest.Builder#expectContinue(boolean)
* expect continue } setting.
*
* @return this request's expect continue setting
*/
public abstract boolean expectContinue();
/**
* Returns this request's request {@code URI}.
*
* @return this request's URI
*/
public abstract URI uri();
/**
* Returns the HTTP protocol version that will be requested for this
* {@code HttpRequest}. The corresponding {@link HttpResponse} should be
* queried to determine the version that was actually used.
*
* @return HTTP protocol version
*/
public abstract HttpClient.Version version();
/**
* The (user-accessible) request headers that this request was (or will be)
* sent with.
*
* @return this request's HttpHeaders
*/
public abstract HttpHeaders headers();
/**
* A request body handler which sends no request body.
*
* @return a BodyProcessor
*/
public static BodyProcessor noBody() {
return new RequestProcessors.EmptyProcessor();
}
/**
* A processor which converts high level Java objects into flows of
* {@link java.nio.ByteBuffer}s suitable for sending as request bodies.
* {@code BodyProcessor}s implement {@link Flow.Publisher} which means they act as a
* publisher of byte buffers.
* <p>
* The HTTP client implementation subscribes to the processor in
* order to receive the flow of outgoing data buffers. The normal semantics
* of {@link Flow.Subscriber} and {@link Flow.Publisher} are implemented
* by the library and expected from processor implementations.
* Each outgoing request results in one {@code Subscriber} subscribing to the
* {@code Publisher} in order to provide the sequence of {@code ByteBuffer}s containing
* the request body. {@code ByteBuffer}s must be allocated by the processor,
* and must not be accessed after being handed over to the library.
* These subscriptions complete normally when the request is fully
* sent, and can be canceled or terminated early through error. If a request
* needs to be resent for any reason, then a new subscription is created
* which is expected to generate the same data as before.
*/
public interface BodyProcessor extends Flow.Publisher<ByteBuffer> {
/**
* Returns a request body processor whose body is the given {@code String},
* converted using the {@link java.nio.charset.StandardCharsets#UTF_8 UTF_8}
* character set.
*
* @param body the String containing the body
* @return a BodyProcessor
*/
static BodyProcessor fromString(String body) {
return fromString(body, StandardCharsets.UTF_8);
}
/**
* Returns a request body processor whose body is the given {@code String}, converted
* using the given character set.
*
* @param s the String containing the body
* @param charset the character set to convert the string to bytes
* @return a BodyProcessor
*/
static BodyProcessor fromString(String s, Charset charset) {
return new RequestProcessors.StringProcessor(s, charset);
}
/**
* A request body processor that reads its data from an {@link java.io.InputStream}.
* A {@link Supplier} of {@code InputStream} is used in case the request needs
* to be sent again as the content is not buffered. The {@code Supplier} may return
* {@code null} on subsequent attempts in which case, the request fails.
*
* @param streamSupplier a Supplier of open InputStreams
* @return a BodyProcessor
*/
// TODO (spec): specify that the stream will be closed
static BodyProcessor fromInputStream(Supplier<? extends InputStream> streamSupplier) {
return new RequestProcessors.InputStreamProcessor(streamSupplier);
}
/**
* Returns a request body processor whose body is the given byte array.
*
* @param buf the byte array containing the body
* @return a BodyProcessor
*/
static BodyProcessor fromByteArray(byte[] buf) {
return new RequestProcessors.ByteArrayProcessor(buf);
}
/**
* Returns a request body processor whose body is the content of the given byte
* array of {@code length} bytes starting from the specified
* {@code offset}.
*
* @param buf the byte array containing the body
* @param offset the offset of the first byte
* @param length the number of bytes to use
* @return a BodyProcessor
*/
static BodyProcessor fromByteArray(byte[] buf, int offset, int length) {
return new RequestProcessors.ByteArrayProcessor(buf, offset, length);
}
/**
* A request body processor that takes data from the contents of a File.
*
* @param path the path to the file containing the body
* @return a BodyProcessor
* @throws java.io.FileNotFoundException if path not found
*/
static BodyProcessor fromFile(Path path) throws FileNotFoundException {
return new RequestProcessors.FileProcessor(path);
}
/**
* A request body processor that takes data from an {@code Iterable} of byte arrays.
* An {@link Iterable} is provided which supplies {@link Iterator} instances.
* Each attempt to send the request results in one invocation of the
* {@code Iterable}
*
* @param iter an Iterable of byte arrays
* @return a BodyProcessor
*/
static BodyProcessor fromByteArrays(Iterable<byte[]> iter) {
return new RequestProcessors.IterableProcessor(iter);
}
/**
* Returns the content length for this request body. May be zero
* if no request content being sent, greater than zero for a fixed
* length content, and less than zero for an unknown content length.
*
* @return the content length for this request body if known
*/
long contentLength();
// /**
// * Returns a used {@code ByteBuffer} to this request processor. When the
// * HTTP implementation has finished sending the contents of a buffer,
// * this method is called to return it to the processor for re-use.
// *
// * @param buffer a used ByteBuffer
// */
//void returnBuffer(ByteBuffer buffer);
}
}