Light, fluffy, and always free - The AWS Local Emulator alternative
fix(cloudfront): stream origin responses and viewer request bodies (#5278)
Priamo Germosen1f1d4f94dd8a
diff --git a/docs/services/cloudfront.md b/docs/services/cloudfront.mdindex 26947ae74f..f5ee9caf74 100644--- a/docs/services/cloudfront.md+++ b/docs/services/cloudfront.md@@ -156,9 +156,12 @@ PUT, PATCH and DELETE).method; any other method returns 403 `Invalid method.`. A behavior without `AllowedMethods` allowsGET and HEAD. Origin forwarding preserves the raw path; custom-origin redirects are not followed.- POST, PUT, PATCH and DELETE are forwarded to custom origins with the viewer request body and its- `Content-Type`; `Content-Length` is set from the body. Their responses are never cached, as on AWS.- Signed URL and signed cookie enforcement applies to them like any other method. Request bodies are- bounded by the emulator-wide `floci.protocols.max-request-size` limit.+ `Content-Type`. The body is streamed to the origin with the viewer's `Content-Length`, or chunked+ when the viewer sent it chunked or, as HTTP/2 allows, with no length, so it is never held in+ memory. Their responses are never cached, as on AWS. Signed URL and signed cookie enforcement+ applies to them like any other method. Request bodies are bounded by the emulator-wide+ `floci.protocols.max-request-size` limit (`FLOCI_PROTOCOLS_MAX_REQUEST_SIZE`, 2048 MB by default);+ CloudFront accepts up to 64 GB, so raise it for larger uploads.- Every distribution is also served as `{id}.cloudfront.{host}` for each endpoint host Flociresolves: `localhost`, `localhost.floci.io`, `localhost.localstack.cloud`, `FLOCI_HOSTNAME` andevery `FLOCI_DNS_EXTRA_SUFFIXES` entry. `{id}.cloudfront.localhost.floci.io` and@@ -223,6 +226,10 @@ PUT, PATCH and DELETE).`Elemental-MediaPackage` or the `UseOriginCacheControlHeaders` policies.- In-process S3 origins do not apply forwarding settings: viewer query strings, cookies and headersdo not change the S3 read.+- Origin responses are streamed to the viewer, from in-process S3 origins and custom origins alike,+ so a large object is never held in memory. A custom origin's `Content-Length` is passed on, and a+ response it sends chunked stays chunked. Floci does not cache, so it serves objects larger than+ 50 GB the way CloudFront does with caching disabled; with caching enabled, CloudFront refuses them.- Origin `Set-Cookie` headers always reach the viewer. With legacy `Forward=none`, AWS strips themfrom the response; Floci does not.- Custom origins that resolve to loopback, private, link-local, carrier-grade NAT, or other non-routable addresses are rejected by default. Development-only private origins must be explicitly allowlisted by exact hostname.diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontOriginHttpClient.java b/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontOriginHttpClient.javaindex 4e7bffe88c..f457afdd92 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontOriginHttpClient.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontOriginHttpClient.java@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.services.cloudfront;import io.github.hectorvent.floci.core.common.SsrfProtection;import org.apache.hc.client5.http.DnsResolver;import org.apache.hc.client5.http.SystemDefaultDnsResolver;+import org.apache.hc.client5.http.classic.methods.HttpUriRequestBase;import org.apache.hc.client5.http.config.ConnectionConfig;import org.apache.hc.client5.http.config.RequestConfig;import org.apache.hc.client5.http.config.TlsConfig;@@ -13,32 +14,32 @@ import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;import org.apache.hc.client5.http.impl.routing.DefaultRoutePlanner;import org.apache.hc.client5.http.protocol.HttpClientContext;+import org.apache.hc.client5.http.routing.RoutingSupport;import org.apache.hc.client5.http.ssl.ClientTlsStrategyBuilder;+import org.apache.hc.core5.http.ClassicHttpResponse;import org.apache.hc.core5.http.Header;+import org.apache.hc.core5.http.HttpEntity;+import org.apache.hc.core5.http.HttpException;import org.apache.hc.core5.http.HttpVersion;-import org.apache.hc.core5.http.io.entity.ByteArrayEntity;-import org.apache.hc.core5.http.io.entity.EntityUtils;-import org.apache.hc.core5.http.io.support.ClassicRequestBuilder;+import org.apache.hc.core5.http.io.entity.InputStreamEntity;import org.apache.hc.core5.http2.HttpVersionPolicy;import org.apache.hc.core5.util.Timeout;+import org.jboss.logging.Logger;import javax.net.ssl.SSLContext;-import javax.net.ssl.SSLSession;+import java.io.FilterInputStream;import java.io.IOException;+import java.io.InputStream;import java.io.InterruptedIOException;import java.net.InetAddress;-import java.net.URI;import java.net.UnknownHostException;-import java.net.http.HttpClient;import java.net.http.HttpHeaders;import java.net.http.HttpRequest;-import java.net.http.HttpResponse;import java.time.Duration;import java.util.ArrayList;import java.util.Collection;import java.util.List;import java.util.Map;-import java.util.Optional;import java.util.Set;import java.util.TreeMap;import java.util.TreeSet;@@ -51,8 +52,11 @@ import java.util.stream.Collectors;*/final class CloudFrontOriginHttpClient implements AutoCloseable {+ private static final Logger LOG = Logger.getLogger(CloudFrontOriginHttpClient.class);+private static final Duration CONNECT_TIMEOUT = Duration.ofSeconds(10);private static final Duration RESPONSE_TIMEOUT = Duration.ofSeconds(30);+ static final int MAX_CONNECTIONS = 100;private final CloseableHttpClient client;@@ -86,8 +90,10 @@ final class CloudFrontOriginHttpClient implements AutoCloseable {.setDnsResolver(validatingResolver).setDefaultConnectionConfig(connectionConfig).setDefaultTlsConfig(tlsConfig)- .setMaxConnTotal(100)- .setMaxConnPerRoute(20);+ // CloudFront has no per-origin connection limit, and a streamed response holds its+ // connection for the whole transfer, so one origin may use the whole pool.+ .setMaxConnTotal(MAX_CONNECTIONS)+ .setMaxConnPerRoute(MAX_CONNECTIONS);if (sslContext != null) {connectionManagerBuilder.setTlsSocketStrategy(ClientTlsStrategyBuilder.create().setSslContext(sslContext)@@ -113,39 +119,139 @@ final class CloudFrontOriginHttpClient implements AutoCloseable {.build();}- HttpResponse<byte[]> send(HttpRequest request, HttpResponse.BodyHandler<byte[]> bodyHandler)- throws IOException, InterruptedException {- return send(request, Map.of(), bodyHandler);+ /**+ * An origin response whose body has not been read. The caller reads {@code body} as it needs it+ * and closes it, which releases the connection. {@code contentLength} is the length the body+ * arrives with, {@code -1} when it comes chunked or with none.+ */+ record OpenResponse(int statusCode, HttpHeaders headers, long contentLength, InputStream body) {}- HttpResponse<byte[]> send(HttpRequest request, Map<String, String> originHeaders,- HttpResponse.BodyHandler<byte[]> bodyHandler)+ /**+ * Sends {@code request} with {@code forwardedHeaders} added and {@code requestBody}, when it is+ * not {@code null}, streamed as the entity, with {@code requestBodyLength} as its+ * {@code Content-Length}, or chunked when the length is negative. Each origin header replaces+ * every same-named request or forwarded header, so a viewer cannot repeat a header to smuggle its+ * own value past an origin custom header. The response comes back before its body is read, so+ * neither body has to fit in memory.+ */+ OpenResponse open(HttpRequest request,+ List<CloudFrontOriginRequestBuilder.Header> forwardedHeaders,+ Map<String, String> originHeaders, InputStream requestBody, long requestBodyLength)throws IOException, InterruptedException {- return send(request, List.of(), originHeaders, null, bodyHandler);+ // No entity content type: the caller's Content-Type request header is sent as is.+ HttpUriRequestBase originRequest = originRequest(request, forwardedHeaders, originHeaders,+ requestBody != null ? new InputStreamEntity(requestBody, requestBodyLength, null) : null);+ ClassicHttpResponse response;+ try {+ response = client.executeOpen(RoutingSupport.determineHost(originRequest), originRequest, context(request));+ } catch (HttpException e) {+ throw new IOException("CloudFront origin request has no target host", e);+ } catch (InterruptedIOException e) {+ if (Thread.currentThread().isInterrupted()) {+ throw new InterruptedException("CloudFront origin request interrupted");+ }+ throw e;+ }+ try {+ HttpEntity entity = response.getEntity();+ InputStream body = entity != null+ ? new ResponseBody(entity.getContent(), originRequest, response)+ : new ResponseBody(InputStream.nullInputStream(), null, response);+ // The entity's length follows the framing the body arrives with; with no entity, as for a+ // HEAD, the header describes the body a GET would get.+ long contentLength = entity != null ? entity.getContentLength() : headerContentLength(response);+ return new OpenResponse(response.getCode(), responseHeaders(response), contentLength, body);+ } catch (IOException | RuntimeException e) {+ originRequest.cancel();+ closeAborted(response);+ throw e;+ }}/**- * Sends {@code request} with {@code forwardedHeaders} added and {@code requestBody} as its- * entity, or with no entity when it is {@code null}. Each origin header replaces every- * same-named request or forwarded header, so a viewer cannot repeat a header to smuggle its own- * value past an origin custom header. The request's own body publisher must be empty: the body- * travels as bytes so its {@code Content-Length} is exact.+ * An origin response body that releases its connection when it is closed. Closed at its end, the+ * connection goes back to the pool. Closed before its end, as when a viewer goes away or a custom+ * error page replaces it, the request is cancelled and the connection closed, since closing the+ * response normally reads the rest of the body to reuse the connection, however long it is.*/- HttpResponse<byte[]> send(HttpRequest request,- List<CloudFrontOriginRequestBuilder.Header> forwardedHeaders,- Map<String, String> originHeaders, byte[] requestBody,- HttpResponse.BodyHandler<byte[]> bodyHandler)+ private static final class ResponseBody extends FilterInputStream {++ private final HttpUriRequestBase request;+ private final ClassicHttpResponse response;+ private boolean finished;++ ResponseBody(InputStream content, HttpUriRequestBase request, ClassicHttpResponse response) {+ super(content);+ this.request = request;+ this.response = response;+ }++ @Override+ public int read() throws IOException {+ int b = super.read();+ finished |= b < 0;+ return b;+ }++ @Override+ public int read(byte[] buffer, int offset, int length) throws IOException {+ int read = super.read(buffer, offset, length);+ finished |= read < 0;+ return read;+ }++ @Override+ public void close() throws IOException {+ if (finished || request == null) {+ try {+ super.close();+ } finally {+ response.close();+ }+ return;+ }+ request.cancel();+ closeAborted(response);+ }+ }++ /** Closes a response whose request was cancelled; reading the rest of it fails, as it should. */+ private static void closeAborted(ClassicHttpResponse response) {+ try {+ response.close();+ } catch (IOException e) {+ LOG.debugv("Closed an unfinished CloudFront origin response: {0}", e.getMessage());+ }+ }++ private static long headerContentLength(ClassicHttpResponse response) {+ Header header = response.getFirstHeader("Content-Length");+ if (header == null) {+ return -1;+ }+ try {+ return Long.parseLong(header.getValue().trim());+ } catch (NumberFormatException e) {+ LOG.debugv("Ignoring an invalid custom-origin Content-Length: {0}", e.getMessage());+ return -1;+ }+ }++ private HttpUriRequestBase originRequest(HttpRequest request,+ List<CloudFrontOriginRequestBuilder.Header> forwardedHeaders,+ Map<String, String> originHeaders, HttpEntity entity)throws IOException, InterruptedException {if (Thread.currentThread().isInterrupted()) {throw new InterruptedException("CloudFront origin request interrupted");}if (request.bodyPublisher().filter(publisher -> publisher.contentLength() != 0).isPresent()) {- throw new IOException("CloudFront origin request bodies must be passed as bytes");+ throw new IOException("CloudFront origin request bodies must be passed separately");}- ClassicRequestBuilder builder = ClassicRequestBuilder.create(request.method())- .setUri(request.uri())- .setVersion(HttpVersion.HTTP_1_1);+ // A request that can be cancelled, so a response closed before its end is not read to the end.+ HttpUriRequestBase builder = new HttpUriRequestBase(request.method(), request.uri());+ builder.setVersion(HttpVersion.HTTP_1_1);Set<String> replaced = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);replaced.addAll(originHeaders.keySet());request.headers().map().forEach((name, values) -> {@@ -159,11 +265,13 @@ final class CloudFrontOriginHttpClient implements AutoCloseable {}}originHeaders.forEach(builder::addHeader);- if (requestBody != null) {- // No entity content type: the caller's Content-Type request header is sent as is.- builder.setEntity(new ByteArrayEntity(requestBody, null));+ if (entity != null) {+ builder.setEntity(entity);}+ return builder;+ }+ private static HttpClientContext context(HttpRequest request) {HttpClientContext context = HttpClientContext.create();Duration responseTimeout = request.timeout().orElse(RESPONSE_TIMEOUT);context.setRequestConfig(RequestConfig.custom()@@ -173,28 +281,16 @@ final class CloudFrontOriginHttpClient implements AutoCloseable {.setContentCompressionEnabled(false).setProtocolUpgradeEnabled(false).build());+ return context;+ }- try {- return client.execute(builder.build(), context, response -> {- Map<String, List<String>> responseHeaders = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);- for (Header header : response.getHeaders()) {- responseHeaders.computeIfAbsent(header.getName(), ignored -> new ArrayList<>())- .add(header.getValue());- }- byte[] body = response.getEntity() != null- ? EntityUtils.toByteArray(response.getEntity())- : new byte[0];- return new PinnedHttpResponse(- response.getCode(), request,- HttpHeaders.of(responseHeaders, (name, value) -> true),- body, request.uri());- });- } catch (InterruptedIOException e) {- if (Thread.currentThread().isInterrupted()) {- throw new InterruptedException("CloudFront origin request interrupted");- }- throw e;+ private static HttpHeaders responseHeaders(ClassicHttpResponse response) {+ Map<String, List<String>> responseHeaders = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);+ for (Header header : response.getHeaders()) {+ responseHeaders.computeIfAbsent(header.getName(), ignored -> new ArrayList<>())+ .add(header.getValue());}+ return HttpHeaders.of(responseHeaders, (name, value) -> true);}@Override@@ -202,29 +298,6 @@ final class CloudFrontOriginHttpClient implements AutoCloseable {client.close();}- private record PinnedHttpResponse(- int statusCode,- HttpRequest request,- HttpHeaders headers,- byte[] body,- URI uri) implements HttpResponse<byte[]> {-- @Override- public Optional<HttpResponse<byte[]>> previousResponse() {- return Optional.empty();- }-- @Override- public Optional<SSLSession> sslSession() {- return Optional.empty();- }-- @Override- public HttpClient.Version version() {- return HttpClient.Version.HTTP_1_1;- }- }-private record ValidatingDnsResolver(DnsResolver delegate, Set<String> allowedHosts)implements DnsResolver {diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontServingController.java b/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontServingController.javaindex 631690112e..37551b01b8 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontServingController.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontServingController.java@@ -30,13 +30,16 @@ import jakarta.ws.rs.core.Context;import jakarta.ws.rs.core.HttpHeaders;import jakarta.ws.rs.core.MediaType;import jakarta.ws.rs.core.Response;+import jakarta.ws.rs.core.StreamingOutput;import jakarta.ws.rs.core.UriInfo;import org.jboss.logging.Logger;+import java.io.IOException;+import java.io.InputStream;+import java.io.PushbackInputStream;import java.net.IDN;import java.net.URI;import java.net.http.HttpRequest;-import java.net.http.HttpResponse;import java.nio.charset.StandardCharsets;import java.time.Duration;import java.time.Instant;@@ -170,7 +173,7 @@ public class CloudFrontServingController {@Path("/{proxy:.*}")@Consumes(MediaType.WILDCARD)public Response post(@PathParam("distId") String distId, @PathParam("proxy") String proxy,- @Context HttpHeaders headers, @Context UriInfo uriInfo, byte[] body) {+ @Context HttpHeaders headers, @Context UriInfo uriInfo, InputStream body) {return serveWithBody(distId, "POST", headers, uriInfo, body);}@@ -178,7 +181,7 @@ public class CloudFrontServingController {@Path("/{proxy:.*}")@Consumes(MediaType.WILDCARD)public Response put(@PathParam("distId") String distId, @PathParam("proxy") String proxy,- @Context HttpHeaders headers, @Context UriInfo uriInfo, byte[] body) {+ @Context HttpHeaders headers, @Context UriInfo uriInfo, InputStream body) {return serveWithBody(distId, "PUT", headers, uriInfo, body);}@@ -186,7 +189,7 @@ public class CloudFrontServingController {@Path("/{proxy:.*}")@Consumes(MediaType.WILDCARD)public Response patch(@PathParam("distId") String distId, @PathParam("proxy") String proxy,- @Context HttpHeaders headers, @Context UriInfo uriInfo, byte[] body) {+ @Context HttpHeaders headers, @Context UriInfo uriInfo, InputStream body) {return serveWithBody(distId, "PATCH", headers, uriInfo, body);}@@ -194,12 +197,12 @@ public class CloudFrontServingController {@Path("/{proxy:.*}")@Consumes(MediaType.WILDCARD)public Response delete(@PathParam("distId") String distId, @PathParam("proxy") String proxy,- @Context HttpHeaders headers, @Context UriInfo uriInfo, byte[] body) {+ @Context HttpHeaders headers, @Context UriInfo uriInfo, InputStream body) {return serveWithBody(distId, "DELETE", headers, uriInfo, body);}private Response serveWithBody(String distId, String method, HttpHeaders headers,- UriInfo uriInfo, byte[] body) {+ UriInfo uriInfo, InputStream body) {HttpServerRequest request = currentVertxRequest.getCurrent().request();String rawViewerPath = rawViewerPath(request.uri());return serve(distId, rawViewerPath, decodedViewerPath(rawViewerPath),@@ -208,7 +211,41 @@ public class CloudFrontServingController {headers.getHeaderString(HttpHeaders.AUTHORIZATION),request.getHeader("Origin"), method, null, null,request.getHeader("Pragma"),- body != null ? body : new byte[0]);+ viewerBody(body, headers.getHeaderString("Transfer-Encoding"),+ headers.getHeaderString(HttpHeaders.CONTENT_LENGTH)));+ }++ /**+ * The viewer's request body and its length. It is {@code -1} when the body comes chunked, which+ * takes precedence over any {@code Content-Length} as HTTP has it, and otherwise the+ * {@code Content-Length}. With neither header an HTTP/1.1 request has no body, but an HTTP/2 one+ * can still send one, so the body is looked at: one that is already at its end is empty, and one+ * that is not is forwarded chunked.+ */+ static ViewerBody viewerBody(InputStream body, String transferEncoding, String contentLength) {+ InputStream stream = body != null ? body : InputStream.nullInputStream();+ if (transferEncoding != null) {+ return new ViewerBody(stream, -1);+ }+ if (contentLength != null && !contentLength.isBlank()) {+ try {+ return new ViewerBody(stream, Long.parseLong(contentLength.trim()));+ } catch (NumberFormatException e) {+ LOG.debugv("Treating an invalid viewer Content-Length as chunked: {0}", e.getMessage());+ return new ViewerBody(stream, -1);+ }+ }+ PushbackInputStream peekable = new PushbackInputStream(stream, 1);+ try {+ int first = peekable.read();+ if (first < 0) {+ return new ViewerBody(InputStream.nullInputStream(), 0);+ }+ peekable.unread(first);+ } catch (IOException e) {+ LOG.debugv("Could not read the start of a viewer request body: {0}", e.getMessage());+ }+ return new ViewerBody(peekable, -1);}private Response serve(String distId, String rawViewerPath, String decodedViewerPath,@@ -218,7 +255,7 @@ public class CloudFrontServingController {String accessControlRequestMethod,String accessControlRequestHeaders,String pragma,- byte[] viewerBody) {+ ViewerBody viewerBody) {boolean includeBody = !"HEAD".equals(method);boolean preflightRequest = "OPTIONS".equals(method)&& viewerOrigin != null && !viewerOrigin.isBlank()@@ -264,8 +301,14 @@ public class CloudFrontServingController {accessControlRequestMethod, accessControlRequestHeaders, viewerBody);if (origin.status() >= 400) {- Response fallback = applyCustomError(- dist, origin, viewerScheme, viewerAuthorization, includeBody, directives);+ Response fallback;+ try {+ fallback = applyCustomError(+ dist, origin, viewerScheme, viewerAuthorization, includeBody, directives);+ } catch (RuntimeException e) {+ origin.closeStream();+ throw e;+ }if (fallback != null) {return fallback;}@@ -408,7 +451,7 @@ public class CloudFrontServingController {String method, String viewerOrigin,String accessControlRequestMethod,String accessControlRequestHeaders,- byte[] viewerBody) {+ ViewerBody viewerBody) {DistributionConfig config = distribution.getConfig();String originId = CloudFrontRequestRouter.matchTargetOriginId(config, normalized);Origin origin = CloudFrontRequestRouter.findOrigin(config, originId);@@ -532,10 +575,12 @@ public class CloudFrontServingController {authorizeS3OriginRead(distribution, origin, bucket, key, viewerAuthorization);if (includeBody) {- S3Object obj = s3Service.getObject(bucket, key);- byte[] data = obj.getData() != null ? obj.getData() : new byte[0];+ // The body is streamed to the viewer, so an object of any size is served without+ // being read into the heap; the metadata and the stream come from one snapshot.+ S3Service.ObjectRead read = s3Service.openObject(bucket, key, null);+ S3Object obj = read.object();response = new OriginResponse(- 200, contentType(obj), data, data.length, s3ObjectHeaders(obj));+ 200, contentType(obj), null, read.body(), obj.getSize(), s3ObjectHeaders(obj));} else {S3Object meta = s3Service.headObject(bucket, key);response = new OriginResponse(@@ -544,8 +589,13 @@ public class CloudFrontServingController {} catch (AwsException e) {response = OriginResponse.error(e.getHttpStatus(), e.getMessage());}- return withS3CorsHeaders(- bucket, origin, includeBody ? "GET" : "HEAD", response);+ try {+ return withS3CorsHeaders(+ bucket, origin, includeBody ? "GET" : "HEAD", response);+ } catch (RuntimeException e) {+ response.closeStream();+ throw e;+ }}private void authorizeS3OriginRead(@@ -642,7 +692,7 @@ public class CloudFrontServingController {*/private OriginResponse fetchFromCustomOrigin(Origin origin, String forwardUri,CloudFrontOriginRequestBuilder.OriginRequest originRequest,- String viewerScheme, String method, byte[] viewerBody) {+ String viewerScheme, String method, ViewerBody viewerBody) {boolean includeBody = !"HEAD".equals(method);try {URI target = buildCustomOriginUri(@@ -665,15 +715,19 @@ public class CloudFrontServingController {}}rb.method(method, HttpRequest.BodyPublishers.noBody());- // The transport derives Content-Length from the body itself.- HttpResponse<byte[]> resp = httpClient.send(rb.build(), originRequest.headers(),- originHeaders, originRequestBody(method, viewerBody),- HttpResponse.BodyHandlers.ofByteArray());+ // Both bodies are streamed, so neither has to fit in memory: the viewer's goes out with its+ // own Content-Length, or chunked as it came, and the origin's comes back as it arrives.+ ViewerBody requestBody = originRequestBody(method, viewerBody);+ CloudFrontOriginHttpClient.OpenResponse resp = httpClient.open(rb.build(), originRequest.headers(),+ originHeaders, requestBody != null ? requestBody.stream() : null,+ requestBody != null ? requestBody.length() : -1);String ct = resp.headers().firstValue("content-type").orElse(DEFAULT_CONTENT_TYPE);- byte[] body = resp.body() != null ? resp.body() : new byte[0];- long contentLength = includeBody ? body.length : responseContentLength(resp);- return new OriginResponse(resp.statusCode(), ct, includeBody ? body : null,- contentLength, resp.headers().map());+ long contentLength = resp.contentLength();+ if (!includeBody) {+ resp.body().close();+ return new OriginResponse(resp.statusCode(), ct, null, contentLength, resp.headers().map());+ }+ return new OriginResponse(resp.statusCode(), ct, null, resp.body(), contentLength, resp.headers().map());} catch (InterruptedException e) {Thread.currentThread().interrupt();LOG.warnv("CloudFront custom origin fetch was interrupted for host {0}",@@ -691,16 +745,20 @@ public class CloudFrontServingController {* The body CloudFront sends to the origin: POST, PUT and PATCH always carry one (possibly empty, so* the origin still sees {@code Content-Length: 0}); DELETE carries one only when the viewer sent it.*/- private static byte[] originRequestBody(String method, byte[] viewerBody) {+ private static ViewerBody originRequestBody(String method, ViewerBody viewerBody) {if (viewerBody == null || !BODY_METHODS.contains(method)) {return null;}- if ("DELETE".equals(method) && viewerBody.length == 0) {+ if ("DELETE".equals(method) && viewerBody.length() == 0) {return null;}return viewerBody;}+ /** A viewer request body, read as it is forwarded, and its length, {@code -1} when it comes chunked. */+ record ViewerBody(InputStream stream, long length) {+ }+private static String originAccessIdentityId(Origin origin) {Map<String, String> config = origin.getS3OriginConfig();String value = config != null ? config.get("OriginAccessIdentity") : null;@@ -798,15 +856,6 @@ public class CloudFrontServingController {return normalized.toLowerCase(Locale.ROOT);}- private static long responseContentLength(HttpResponse<?> response) {- try {- return response.headers().firstValueAsLong("content-length").orElse(-1L);- } catch (NumberFormatException e) {- LOG.debugv("Ignoring invalid custom-origin Content-Length: {0}", e.getMessage());- return -1L;- }- }-private static String safeOriginName(Origin origin) {try {return normalizeOriginHost(origin.getDomainName());@@ -847,8 +896,7 @@ public class CloudFrontServingController {String pagePath = str(cer.get("ResponsePagePath"));if (pagePath.isBlank()) {// ResponseCode override with no custom page: keep the origin body, change the status.- return toResponse(new OriginResponse(responseCode, origin.contentType(), origin.body(),- origin.contentLength(), origin.headers()), includeBody, directives);+ return toResponse(origin.withStatus(responseCode), includeBody, directives);}String errNormalized = CloudFrontRequestRouter.normalizePath(pagePath);@@ -858,6 +906,8 @@ public class CloudFrontServingController {return null;}+ // The custom error page replaces the origin's error response, which is not sent.+ origin.closeStream();OriginResponse page;if (CloudFrontRequestRouter.isS3Origin(errOrigin)) {String key = CloudFrontRequestRouter.resolveOriginKey(errOrigin.getOriginPath(), errNormalized, null);@@ -874,8 +924,7 @@ public class CloudFrontServingController {// (AWS behavior), without recursively applying custom error handling.return toResponse(page, includeBody, directives);}- return toResponse(new OriginResponse(responseCode, page.contentType(), page.body(),- page.contentLength(), page.headers()), includeBody, directives);+ return toResponse(page.withStatus(responseCode), includeBody, directives);}private Map<String, Object> matchCustomError(DistributionConfig config, int status) {@@ -893,21 +942,40 @@ public class CloudFrontServingController {private Response toResponse(OriginResponse origin, boolean includeBody,ResponseHeadersPolicyConfigCodec.Directives directives) {- Response.ResponseBuilder rb = Response.status(origin.status());- HeaderCollection collected = collectResponseHeaders(origin, includeBody);- applyResponseHeadersPolicy(collected.headers(), directives, collected.forbiddenPolicyHeaders());- for (HeaderValues header : collected.headers().values()) {- if ("date".equalsIgnoreCase(header.name())) {- currentVertxRequest.getCurrent().response()- .putHeader(header.name(), header.values());+ try {+ Response.ResponseBuilder rb = Response.status(origin.status());+ HeaderCollection collected = collectResponseHeaders(origin, includeBody);+ applyResponseHeadersPolicy(collected.headers(), directives, collected.forbiddenPolicyHeaders());+ for (HeaderValues header : collected.headers().values()) {+ if ("date".equalsIgnoreCase(header.name())) {+ currentVertxRequest.getCurrent().response()+ .putHeader(header.name(), header.values());+ } else {+ header.values().forEach(value -> rb.header(header.name(), value));+ }+ }+ if (includeBody && origin.stream() != null) {+ InputStream body = origin.stream();+ StreamingOutput entity = output -> {+ try (InputStream in = body) {+ in.transferTo(output);+ }+ };+ rb.entity(entity);} else {- header.values().forEach(value -> rb.header(header.name(), value));+ if (origin.stream() != null) {+ // A body that will not be sent, as for a HEAD, still holds its source open.+ origin.closeStream();+ }+ if (includeBody && origin.body() != null) {+ rb.entity(origin.body());+ }}+ return rb.build();+ } catch (RuntimeException e) {+ origin.closeStream();+ throw e;}- if (includeBody && origin.body() != null) {- rb.entity(origin.body());- }- return rb.build();}/**@@ -943,7 +1011,8 @@ public class CloudFrontServingController {if (origin.contentType() != null) {setHeader(headers, "Content-Type", origin.contentType());}- if (!includeBody && origin.contentLength() >= 0) {+ // A byte body sets its own length; a HEAD response and a streamed body need it stated.+ if ((!includeBody || origin.stream() != null) && origin.contentLength() >= 0) {setHeader(headers, "Content-Length", Long.toString(origin.contentLength()));}return new HeaderCollection(headers, forbiddenPolicyHeaders);@@ -1094,12 +1163,7 @@ public class CloudFrontServingController {"Access-Control-Request-Method"));}});- return new OriginResponse(- response.status(),- response.contentType(),- response.body(),- response.contentLength(),- headers);+ return response.withHeaders(headers);}private static String originCustomHeader(Origin origin, String requestedName) {@@ -1192,12 +1256,42 @@ public class CloudFrontServingController {Set<String> forbiddenPolicyHeaders) {}- /** The result of fetching from an origin, including end-to-end response headers. */- private record OriginResponse(int status, String contentType, byte[] body, long contentLength,- Map<String, List<String>> headers) {+ /**+ * The result of fetching from an origin, including end-to-end response headers. An origin's+ * content, from an S3 object or a custom origin, is an open {@code stream} instead of+ * {@code body}, so it never passes through the heap; the viewer response writes and closes it.+ * {@code body} holds the bytes of a response Floci makes itself, such as an error.+ */+ private record OriginResponse(int status, String contentType, byte[] body, InputStream stream,+ long contentLength, Map<String, List<String>> headers) {+ OriginResponse(int status, String contentType, byte[] body, long contentLength,+ Map<String, List<String>> headers) {+ this(status, contentType, body, null, contentLength, headers);+ }+static OriginResponse error(int status, String message) {byte[] b = message == null ? new byte[0] : message.getBytes(StandardCharsets.UTF_8);return new OriginResponse(status, MediaType.TEXT_PLAIN, b, b.length, Map.of());}++ OriginResponse withStatus(int newStatus) {+ return new OriginResponse(newStatus, contentType, body, stream, contentLength, headers);+ }++ OriginResponse withHeaders(Map<String, List<String>> newHeaders) {+ return new OriginResponse(status, contentType, body, stream, contentLength, newHeaders);+ }++ /** Closes the stream of a response that will not be written. */+ void closeStream() {+ if (stream == null) {+ return;+ }+ try {+ stream.close();+ } catch (IOException e) {+ LOG.debugv("Could not close an unsent origin body: {0}", e.getMessage());+ }+ }}}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontCustomOriginServingTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontCustomOriginServingTest.javaindex e7f97c1bb1..18197a5cfa 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontCustomOriginServingTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontCustomOriginServingTest.java@@ -16,22 +16,29 @@ import io.github.hectorvent.floci.services.cloudfront.model.ResponseHeadersPolicimport io.quarkus.test.junit.QuarkusTest;import io.quarkus.test.junit.QuarkusTestProfile;import io.quarkus.test.junit.TestProfile;+import io.restassured.RestAssured;import io.restassured.response.Response;import jakarta.inject.Inject;import org.junit.jupiter.api.AfterEach;import org.junit.jupiter.api.Test;+import java.io.BufferedReader;import java.io.IOException;+import java.io.InputStreamReader;+import java.io.OutputStream;import java.net.InetSocketAddress;+import java.net.Socket;import java.nio.charset.StandardCharsets;import java.security.KeyPair;import java.security.KeyPairGenerator;import java.security.Signature;+import java.time.Duration;import java.time.Instant;import java.util.Base64;import java.util.LinkedHashMap;import java.util.List;import java.util.Map;+import java.util.Random;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.atomic.AtomicInteger;import java.util.concurrent.atomic.AtomicReference;@@ -43,6 +50,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertNotEquals;import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively;import static org.junit.jupiter.api.Assertions.assertTrue;@QuarkusTest@@ -316,6 +324,106 @@ class CloudFrontCustomOriginServingTest {assertEquals(5, hits.get());}+ @Test+ void streamsALargeOriginResponseWithItsLength() throws Exception {+ byte[] video = randomBytes(3 * 1024 * 1024 + 1);+ startServingOrigin(video, true);+ Distribution created = cloudFrontService.createDistribution(+ customOriginDistribution(allMethodsBehavior()), Map.of());++ Response response = given().header("Host", created.getDomainName()).when().get("/video.bin");++ assertEquals(200, response.statusCode());+ assertEquals(Integer.toString(video.length), response.header("Content-Length"));+ assertArrayEquals(video, response.asByteArray());+ }++ @Test+ void passesAChunkedOriginResponseThroughChunked() throws Exception {+ byte[] video = randomBytes(3 * 1024 * 1024 + 1);+ startServingOrigin(video, false);+ Distribution created = cloudFrontService.createDistribution(+ customOriginDistribution(allMethodsBehavior()), Map.of());++ Response response = given().header("Host", created.getDomainName()).when().get("/video.bin");++ assertEquals(200, response.statusCode());+ assertNull(response.header("Content-Length"), "an origin that sent no length was given one");+ assertArrayEquals(video, response.asByteArray());+ }++ @Test+ void streamsALargeViewerBodyToTheOriginWithItsLength() throws Exception {+ AtomicReference<ReceivedRequest> received = new AtomicReference<>();+ startRecordingOrigin(received, new AtomicInteger());+ Distribution created = cloudFrontService.createDistribution(+ customOriginDistribution(allMethodsBehavior()), Map.of());+ byte[] upload = randomBytes(3 * 1024 * 1024 + 1);++ given()+ .header("Host", created.getDomainName())+ .contentType("application/octet-stream")+ .body(upload)+ .when()+ .put("/uploads/video.bin")+ .then()+ .statusCode(200);++ assertEquals(Integer.toString(upload.length), received.get().header("Content-Length"));+ assertArrayEquals(upload, received.get().body());+ }++ @Test+ void forwardsAChunkedViewerBodyChunked() throws Exception {+ AtomicReference<ReceivedRequest> received = new AtomicReference<>();+ startRecordingOrigin(received, new AtomicInteger());+ Distribution created = cloudFrontService.createDistribution(+ customOriginDistribution(allMethodsBehavior()), Map.of());+ byte[] upload = randomBytes(200_001);++ int status = assertTimeoutPreemptively(Duration.ofSeconds(60),+ () -> postChunked(created.getDomainName(), "/uploads", upload));++ assertEquals(201, status);+ assertEquals("chunked", received.get().header("Transfer-Encoding"));+ assertNull(received.get().header("Content-Length"));+ assertArrayEquals(upload, received.get().body());+ }++ @Test+ void releasesTheOriginConnectionOfEveryResponseItDoesNotSend() throws Exception {+ // The origin client keeps a fixed number of connections. An error response replaced by a custom+ // error page, or a HEAD's, that kept its connection would leave a request past that number+ // waiting for one.+ originServer = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);+ originServer.createContext("/", exchange -> {+ boolean errorPage = "/errors/404.html".equals(exchange.getRequestURI().getRawPath());+ byte[] body = (errorPage ? "error-page" : "x".repeat(100_000)).getBytes(StandardCharsets.UTF_8);+ exchange.getResponseHeaders().add("Content-Type", "text/plain");+ boolean head = "HEAD".equals(exchange.getRequestMethod());+ exchange.sendResponseHeaders(errorPage ? 200 : 404, head ? -1 : body.length);+ if (!head) {+ exchange.getResponseBody().write(body);+ }+ exchange.close();+ });+ originServer.start();+ Map<String, Object> errorPage = new LinkedHashMap<>(Map.of(+ "ErrorCode", "404", "ResponseCode", "200", "ResponsePagePath", "/errors/404.html"));+ Distribution distribution = customOriginDistribution(allMethodsBehavior());+ distribution.getConfig().setCustomErrorResponses(List.of(errorPage));+ Distribution created = cloudFrontService.createDistribution(distribution, Map.of());++ assertTimeoutPreemptively(Duration.ofSeconds(60), () -> {+ for (int i = 0; i < CloudFrontOriginHttpClient.MAX_CONNECTIONS + 10; i++) {+ given().header("Host", created.getDomainName()).when().get("/missing/" + i)+ .then().statusCode(200).body(equalTo("error-page"));+ given().header("Host", created.getDomainName()).when().head("/missing/" + i)+ .then().statusCode(200);+ }+ });+ }+@Testvoid forwardsTheViewerAuthorizationOnWriteMethodsOnly() throws Exception {AtomicReference<ReceivedRequest> received = new AtomicReference<>();@@ -705,6 +813,51 @@ class CloudFrontCustomOriginServingTest {originServer.start();}+ /** An origin that answers every GET with {@code body}, with its length or chunked. */+ private void startServingOrigin(byte[] body, boolean withLength) throws IOException {+ originServer = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);+ originServer.createContext("/", exchange -> {+ exchange.getRequestBody().readAllBytes();+ exchange.getResponseHeaders().add("Content-Type", "application/octet-stream");+ exchange.sendResponseHeaders(200, withLength ? body.length : 0);+ exchange.getResponseBody().write(body);+ exchange.close();+ });+ originServer.start();+ }++ /**+ * POSTs {@code body} with {@code Transfer-Encoding: chunked} over a raw connection, since an HTTP+ * client library buffers a stream it is given and sends its length instead.+ */+ private static int postChunked(String host, String path, byte[] body) throws IOException {+ try (Socket socket = new Socket("localhost", RestAssured.port)) {+ // A response that never comes fails the read instead of leaving it waiting.+ socket.setSoTimeout(30_000);+ OutputStream out = socket.getOutputStream();+ out.write(("POST " + path + " HTTP/1.1\r\nHost: " + host+ + "\r\nContent-Type: application/octet-stream\r\nTransfer-Encoding: chunked"+ + "\r\nConnection: close\r\n\r\n").getBytes(StandardCharsets.US_ASCII));+ for (int offset = 0; offset < body.length; offset += 8192) {+ int size = Math.min(8192, body.length - offset);+ out.write((Integer.toHexString(size) + "\r\n").getBytes(StandardCharsets.US_ASCII));+ out.write(body, offset, size);+ out.write("\r\n".getBytes(StandardCharsets.US_ASCII));+ }+ out.write("0\r\n\r\n".getBytes(StandardCharsets.US_ASCII));+ out.flush();+ String statusLine = new BufferedReader(+ new InputStreamReader(socket.getInputStream(), StandardCharsets.US_ASCII)).readLine();+ return Integer.parseInt(statusLine.split(" ")[1]);+ }+ }++ private static byte[] randomBytes(int size) {+ byte[] bytes = new byte[size];+ new Random(size).nextBytes(bytes);+ return bytes;+ }+private Distribution customOriginDistribution(DefaultCacheBehavior behavior) {return customOriginDistribution(behavior, null);}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontDistributionServingTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontDistributionServingTest.javaindex 5dbb0fb40a..ffa319f7c1 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontDistributionServingTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontDistributionServingTest.java@@ -274,6 +274,7 @@ class CloudFrontDistributionServingTest {.header("x-amz-meta-source", equalTo("origin")).header("x-amz-server-side-encryption", nullValue()).header("x-amz-checksum-sha256", nullValue())+ .header("Content-Length", equalTo(Integer.toString(body.getBytes(StandardCharsets.UTF_8).length))).body(equalTo(body));given().header("Host", dist.getDomainName()).when().head("/asset.txt")diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontOriginHttpClientTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontOriginHttpClientTest.javaindex 63203cfc92..eff729e66b 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontOriginHttpClientTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontOriginHttpClientTest.java@@ -17,12 +17,15 @@ import javax.net.ssl.SNIHostName;import javax.net.ssl.SNIServerName;import javax.net.ssl.SSLContext;import javax.net.ssl.TrustManagerFactory;+import java.io.ByteArrayInputStream;import java.io.IOException;+import java.io.InputStream;+import java.io.OutputStream;import java.net.InetAddress;import java.net.InetSocketAddress;+import java.net.URI;import java.net.UnknownHostException;import java.net.http.HttpRequest;-import java.net.http.HttpResponse;import java.nio.charset.StandardCharsets;import java.security.KeyStore;import java.security.Security;@@ -30,12 +33,18 @@ import java.security.cert.X509Certificate;import java.time.Duration;import java.util.List;import java.util.Map;+import java.util.Random;+import java.util.concurrent.CopyOnWriteArrayList;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicInteger;+import java.util.concurrent.atomic.AtomicLong;import java.util.concurrent.atomic.AtomicReference;import static org.junit.jupiter.api.Assertions.assertArrayEquals;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;class CloudFrontOriginHttpClientTest {@@ -47,8 +56,7 @@ class CloudFrontOriginHttpClientTest {resolver(InetAddress.getByName("127.0.0.1")), List.of())) {HttpRequest request = request("http://blocked.invalid:" + server.getAddress().getPort() + "/");- assertThrows(UnknownHostException.class,- () -> client.send(request, HttpResponse.BodyHandlers.ofByteArray()));+ assertThrows(UnknownHostException.class, () -> get(client, request));assertEquals(0, hits.get());} finally {server.stop(0);@@ -61,9 +69,7 @@ class CloudFrontOriginHttpClientTest {InetAddress.getByName("8.8.8.8"),InetAddress.getByName("127.0.0.1"));try (CloudFrontOriginHttpClient client = new CloudFrontOriginHttpClient(resolver, List.of())) {- assertThrows(UnknownHostException.class, () -> client.send(- request("http://mixed.invalid:8080/"),- HttpResponse.BodyHandlers.ofByteArray()));+ assertThrows(UnknownHostException.class, () -> get(client, request("http://mixed.invalid:8080/")));}}@@ -100,12 +106,11 @@ class CloudFrontOriginHttpClientTest {try (CloudFrontOriginHttpClient client = new CloudFrontOriginHttpClient(resolver, List.of("rebind.invalid"))) {- HttpResponse<byte[]> response = client.send(- request("http://rebind.invalid:" + server.getAddress().getPort() + "/"),- HttpResponse.BodyHandlers.ofByteArray());+ CloudFrontOriginHttpClient.OpenResponse response = get(client,+ request("http://rebind.invalid:" + server.getAddress().getPort() + "/"));assertEquals(200, response.statusCode());- assertArrayEquals("origin-ok".getBytes(StandardCharsets.UTF_8), response.body());+ assertArrayEquals("origin-ok".getBytes(StandardCharsets.UTF_8), readAll(response));assertEquals(1, resolutions.get());assertEquals(1, hits.get());assertEquals("rebind.invalid:" + server.getAddress().getPort(), hostHeader.get());@@ -132,9 +137,9 @@ class CloudFrontOriginHttpClientTest {try (CloudFrontOriginHttpClient client = new CloudFrontOriginHttpClient(resolver(InetAddress.getByName("127.0.0.1")), List.of("redirect.invalid"))) {- HttpResponse<byte[]> response = client.send(- request("http://redirect.invalid:" + server.getAddress().getPort() + "/start"),- HttpResponse.BodyHandlers.ofByteArray());+ CloudFrontOriginHttpClient.OpenResponse response = get(client,+ request("http://redirect.invalid:" + server.getAddress().getPort() + "/start"));+ readAll(response);assertEquals(302, response.statusCode());assertEquals(0, redirectedHits.get());@@ -163,10 +168,7 @@ class CloudFrontOriginHttpClientTest {.GET().build();- client.send(- request,- Map.of("X-Origin-Verify", "configured-value"),- HttpResponse.BodyHandlers.ofByteArray());+ readAll(client.open(request, List.of(), Map.of("X-Origin-Verify", "configured-value"), null, -1));assertEquals(List.of("configured-value"), receivedValues.get());} finally {@@ -201,8 +203,9 @@ class CloudFrontOriginHttpClientTest {.method("PUT", HttpRequest.BodyPublishers.noBody()).build();- HttpResponse<byte[]> response = client.send(- request, List.of(), Map.of(), payload, HttpResponse.BodyHandlers.ofByteArray());+ CloudFrontOriginHttpClient.OpenResponse response = client.open(+ request, List.of(), Map.of(), new ByteArrayInputStream(payload), payload.length);+ readAll(response);assertEquals(204, response.statusCode());assertEquals("PUT", method.get());@@ -250,21 +253,125 @@ class CloudFrontOriginHttpClientTest {try (CloudFrontOriginHttpClient client = new CloudFrontOriginHttpClient(resolver, List.of("origin.invalid", "wrong.invalid"), clientContext)) {int port = server.getAddress().getPort();- HttpResponse<byte[]> response = client.send(- request("https://origin.invalid:" + port + "/"),- HttpResponse.BodyHandlers.ofByteArray());+ CloudFrontOriginHttpClient.OpenResponse response = get(client,+ request("https://origin.invalid:" + port + "/"));+ readAll(response);assertEquals(200, response.statusCode());assertEquals("origin.invalid:" + port, hostHeader.get());assertEquals("origin.invalid", requestedSni.get());- assertThrows(IOException.class, () -> client.send(- request("https://wrong.invalid:" + port + "/"),- HttpResponse.BodyHandlers.ofByteArray()));+ assertThrows(IOException.class, () -> get(client, request("https://wrong.invalid:" + port + "/")));} finally {server.stop(0);}}+ @Test+ void streamsARequestBodyChunkedWhenItsLengthIsUnknown() throws Exception {+ AtomicReference<String> transferEncoding = new AtomicReference<>();+ AtomicReference<byte[]> body = new AtomicReference<>();+ HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);+ server.createContext("/", exchange -> {+ transferEncoding.set(exchange.getRequestHeaders().getFirst("Transfer-Encoding"));+ body.set(exchange.getRequestBody().readAllBytes());+ exchange.sendResponseHeaders(204, -1);+ exchange.close();+ });+ server.start();++ byte[] payload = new byte[100_000];+ new Random(1).nextBytes(payload);+ try (CloudFrontOriginHttpClient client = new CloudFrontOriginHttpClient(+ resolver(InetAddress.getByName("127.0.0.1")), List.of("origin.invalid"))) {+ HttpRequest request = HttpRequest.newBuilder(URI.create(+ "http://origin.invalid:" + server.getAddress().getPort() + "/items"))+ .timeout(Duration.ofSeconds(5))+ .method("POST", HttpRequest.BodyPublishers.noBody())+ .build();++ readAll(client.open(request, List.of(), Map.of(), new ByteArrayInputStream(payload), -1));++ assertEquals("chunked", transferEncoding.get());+ assertArrayEquals(payload, body.get());+ } finally {+ server.stop(0);+ }+ }++ @Test+ void closingAResponseBeforeItsEndDoesNotReadTheRestOfIt() throws Exception {+ long size = 512L * 1024 * 1024;+ AtomicLong sent = new AtomicLong();+ CountDownLatch done = new CountDownLatch(1);+ HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);+ server.createContext("/", exchange -> {+ byte[] chunk = new byte[64 * 1024];+ exchange.sendResponseHeaders(200, size);+ try (OutputStream out = exchange.getResponseBody()) {+ for (long written = 0; written < size; written += chunk.length) {+ out.write(chunk);+ sent.addAndGet(chunk.length);+ }+ } catch (IOException expected) {+ // The client went away mid-body, which is what the test does.+ } finally {+ done.countDown();+ }+ });+ server.start();++ try (CloudFrontOriginHttpClient client = new CloudFrontOriginHttpClient(+ resolver(InetAddress.getByName("127.0.0.1")), List.of("origin.invalid"))) {+ CloudFrontOriginHttpClient.OpenResponse response = get(client,+ request("http://origin.invalid:" + server.getAddress().getPort() + "/big"));+ assertEquals(size, response.contentLength());+ response.body().readNBytes(1024);+ response.body().close();++ assertTrue(done.await(30, TimeUnit.SECONDS), "the origin is still sending");+ assertTrue(sent.get() < size / 2, "closing read " + (sent.get() >> 20) + " MiB of " + (size >> 20));+ } finally {+ server.stop(0);+ }+ }++ @Test+ void aResponseReadToItsEndLeavesItsConnectionForTheNextRequest() throws Exception {+ List<InetSocketAddress> peers = new CopyOnWriteArrayList<>();+ HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);+ server.createContext("/", exchange -> {+ peers.add(exchange.getRemoteAddress());+ byte[] body = "origin-ok".getBytes(StandardCharsets.UTF_8);+ exchange.sendResponseHeaders(200, body.length);+ exchange.getResponseBody().write(body);+ exchange.close();+ });+ server.start();++ try (CloudFrontOriginHttpClient client = new CloudFrontOriginHttpClient(+ resolver(InetAddress.getByName("127.0.0.1")), List.of("origin.invalid"))) {+ String uri = "http://origin.invalid:" + server.getAddress().getPort() + "/";+ readAll(get(client, request(uri)));+ readAll(get(client, request(uri)));++ assertEquals(2, peers.size());+ assertEquals(peers.get(0), peers.get(1), "the second request opened a new connection");+ } finally {+ server.stop(0);+ }+ }++ private static CloudFrontOriginHttpClient.OpenResponse get(CloudFrontOriginHttpClient client,+ HttpRequest request) throws Exception {+ return client.open(request, List.of(), Map.of(), null, -1);+ }++ private static byte[] readAll(CloudFrontOriginHttpClient.OpenResponse response) throws IOException {+ try (InputStream body = response.body()) {+ return body.readAllBytes();+ }+ }+private static HttpServer server(AtomicInteger hits) throws Exception {HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);server.createContext("/", exchange -> {diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontS3DiskOriginServingTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontS3DiskOriginServingTest.javanew file mode 100644index 0000000000..f6b539d186--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontS3DiskOriginServingTest.java@@ -0,0 +1,108 @@+package io.github.hectorvent.floci.services.cloudfront;++import io.github.hectorvent.floci.services.cloudfront.model.DefaultCacheBehavior;+import io.github.hectorvent.floci.services.cloudfront.model.Distribution;+import io.github.hectorvent.floci.services.cloudfront.model.DistributionConfig;+import io.github.hectorvent.floci.services.cloudfront.model.Origin;+import io.github.hectorvent.floci.services.s3.S3Service;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.QuarkusTestProfile;+import io.quarkus.test.junit.TestProfile;+import io.restassured.response.Response;+import jakarta.inject.Inject;+import org.junit.jupiter.api.Test;++import java.nio.charset.StandardCharsets;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;+import java.util.Random;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.junit.jupiter.api.Assertions.assertArrayEquals;+import static org.junit.jupiter.api.Assertions.assertEquals;++/**+ * An S3 origin whose objects live on disk, where CloudFront streams the object file to the viewer+ * instead of reading it into memory first.+ */+@QuarkusTest+@TestProfile(CloudFrontS3DiskOriginServingTest.S3OnDiskProfile.class)+class CloudFrontS3DiskOriginServingTest {++ private static final String REGION = "us-east-1";++ @Inject+ S3Service s3Service;++ @Inject+ CloudFrontService cloudFrontService;++ @Test+ void streamsAnObjectFileWithItsLength() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String bucket = "cf-disk-origin-" + suffix;+ // Larger than any one buffer on the way, so the body arrives over many writes.+ byte[] body = new byte[3 * 1024 * 1024 + 1];+ new Random(5080).nextBytes(body);+ s3Service.createBucket(bucket, REGION);+ try {+ s3Service.putObject(bucket, "video.bin", body, "application/octet-stream", Map.of());+ s3Service.putObject(bucket, "index.html", ("INDEX-ON-DISK-" + suffix).getBytes(StandardCharsets.UTF_8),+ "text/html", Map.of());+ Distribution dist = distributionFor(bucket);++ Response get = given().header("Host", dist.getDomainName()).when().get("/video.bin");++ assertEquals(200, get.statusCode());+ assertEquals(Integer.toString(body.length), get.header("Content-Length"));+ assertArrayEquals(body, get.asByteArray());+ given().header("Host", dist.getDomainName()).when().head("/video.bin")+ .then().statusCode(200)+ .header("Content-Length", equalTo(Integer.toString(body.length)));+ // The single-page-app fallback serves its error page through the same stream.+ given().header("Host", dist.getDomainName()).when().get("/missing/route")+ .then().statusCode(200)+ .header("Content-Length", equalTo(Integer.toString(("INDEX-ON-DISK-" + suffix).length())))+ .body(containsString("INDEX-ON-DISK-" + suffix));+ } finally {+ // The bucket is on disk and outlives the test, so it is removed rather than left for the next run.+ s3Service.deleteObject(bucket, "video.bin");+ s3Service.deleteObject(bucket, "index.html");+ s3Service.deleteBucket(bucket);+ }+ }++ private Distribution distributionFor(String bucket) {+ Origin origin = new Origin();+ origin.setId("disk-origin");+ origin.setDomainName(bucket + ".s3." + REGION + ".amazonaws.com");+ origin.setS3OriginConfig(new LinkedHashMap<>(Map.of("OriginAccessIdentity", "")));+ DefaultCacheBehavior behavior = new DefaultCacheBehavior();+ behavior.setTargetOriginId(origin.getId());+ behavior.setViewerProtocolPolicy("allow-all");+ Map<String, Object> spaFallback = new LinkedHashMap<>();+ spaFallback.put("ErrorCode", "404");+ spaFallback.put("ResponseCode", "200");+ spaFallback.put("ResponsePagePath", "/index.html");+ DistributionConfig config = new DistributionConfig();+ config.setEnabled(true);+ config.setOrigins(List.of(origin));+ config.setDefaultCacheBehavior(behavior);+ config.setCustomErrorResponses(List.of(spaFallback));+ Distribution distribution = new Distribution();+ distribution.setConfig(config);+ return cloudFrontService.createDistribution(distribution, Map.of());+ }++ public static final class S3OnDiskProfile implements QuarkusTestProfile {+ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of(+ "floci.storage.services.s3.mode", "persistent",+ "floci.storage.persistent-path", "target/cloudfront-s3-disk-origin-it");+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontViewerBodyTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontViewerBodyTest.javanew file mode 100644index 0000000000..f0043a7406--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudfront/CloudFrontViewerBodyTest.java@@ -0,0 +1,62 @@+package io.github.hectorvent.floci.services.cloudfront;++import org.junit.jupiter.api.Test;++import java.io.ByteArrayInputStream;+import java.io.IOException;+import java.io.InputStream;+import java.nio.charset.StandardCharsets;++import static org.junit.jupiter.api.Assertions.assertArrayEquals;+import static org.junit.jupiter.api.Assertions.assertEquals;++/** How the length of a viewer's request body is taken before it is forwarded to a custom origin. */+class CloudFrontViewerBodyTest {++ private static final byte[] DATA = "a viewer upload".getBytes(StandardCharsets.UTF_8);++ @Test+ void aChunkedBodyIsForwardedChunkedWhateverItsContentLength() throws IOException {+ CloudFrontServingController.ViewerBody body =+ CloudFrontServingController.viewerBody(new ByteArrayInputStream(DATA), "chunked", "3");++ assertEquals(-1, body.length());+ assertArrayEquals(DATA, readAll(body));+ }++ @Test+ void aBodyWithAContentLengthKeepsIt() throws IOException {+ CloudFrontServingController.ViewerBody body = CloudFrontServingController.viewerBody(+ new ByteArrayInputStream(DATA), null, Integer.toString(DATA.length));++ assertEquals(DATA.length, body.length());+ assertArrayEquals(DATA, readAll(body));+ }++ @Test+ void anInvalidContentLengthIsForwardedChunked() {+ assertEquals(-1, CloudFrontServingController.viewerBody(+ new ByteArrayInputStream(DATA), null, "not-a-length").length());+ }++ @Test+ void aRequestWithNeitherHeaderAndNoBodyIsEmpty() {+ assertEquals(0, CloudFrontServingController.viewerBody(InputStream.nullInputStream(), null, null).length());+ assertEquals(0, CloudFrontServingController.viewerBody(null, null, null).length());+ }++ @Test+ void aBodyWithNeitherHeaderAsHttp2AllowsIsForwardedChunkedAndWhole() throws IOException {+ CloudFrontServingController.ViewerBody body =+ CloudFrontServingController.viewerBody(new ByteArrayInputStream(DATA), null, null);++ assertEquals(-1, body.length());+ assertArrayEquals(DATA, readAll(body), "the byte read to look at the body was lost");+ }++ private static byte[] readAll(CloudFrontServingController.ViewerBody body) throws IOException {+ try (InputStream stream = body.stream()) {+ return stream.readAllBytes();+ }+ }+}