Light, fluffy, and always free - The AWS Local Emulator alternative
chore(core): own the Docker HTTP transport, with docker-java's settings unchanged (#5170)
Hector Venturadf958117bbf8
diff --git a/licenses/Apache-2.0.txt b/licenses/Apache-2.0.txtnew file mode 100644index 0000000000..38275f2f4f--- /dev/null+++ b/licenses/Apache-2.0.txt@@ -0,0 +1,202 @@++ Apache License+ Version 2.0, January 2004+ http://www.apache.org/licenses/++ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION++ 1. Definitions.++ "License" shall mean the terms and conditions for use, reproduction,+ and distribution as defined by Sections 1 through 9 of this document.++ "Licensor" shall mean the copyright owner or entity authorized by+ the copyright owner that is granting the License.++ "Legal Entity" shall mean the union of the acting entity and all+ other entities that control, are controlled by, or are under common+ control with that entity. For the purposes of this definition,+ "control" means (i) the power, direct or indirect, to cause the+ direction or management of such entity, whether by contract or+ otherwise, or (ii) ownership of fifty percent (50%) or more of the+ outstanding shares, or (iii) beneficial ownership of such entity.++ "You" (or "Your") shall mean an individual or Legal Entity+ exercising permissions granted by this License.++ "Source" form shall mean the preferred form for making modifications,+ including but not limited to software source code, documentation+ source, and configuration files.++ "Object" form shall mean any form resulting from mechanical+ transformation or translation of a Source form, including but+ not limited to compiled object code, generated documentation,+ and conversions to other media types.++ "Work" shall mean the work of authorship, whether in Source or+ Object form, made available under the License, as indicated by a+ copyright notice that is included in or attached to the work+ (an example is provided in the Appendix below).++ "Derivative Works" shall mean any work, whether in Source or Object+ form, that is based on (or derived from) the Work and for which the+ editorial revisions, annotations, elaborations, or other modifications+ represent, as a whole, an original work of authorship. For the purposes+ of this License, Derivative Works shall not include works that remain+ separable from, or merely link (or bind by name) to the interfaces of,+ the Work and Derivative Works thereof.++ "Contribution" shall mean any work of authorship, including+ the original version of the Work and any modifications or additions+ to that Work or Derivative Works thereof, that is intentionally+ submitted to Licensor for inclusion in the Work by the copyright owner+ or by an individual or Legal Entity authorized to submit on behalf of+ the copyright owner. For the purposes of this definition, "submitted"+ means any form of electronic, verbal, or written communication sent+ to the Licensor or its representatives, including but not limited to+ communication on electronic mailing lists, source code control systems,+ and issue tracking systems that are managed by, or on behalf of, the+ Licensor for the purpose of discussing and improving the Work, but+ excluding communication that is conspicuously marked or otherwise+ designated in writing by the copyright owner as "Not a Contribution."++ "Contributor" shall mean Licensor and any individual or Legal Entity+ on behalf of whom a Contribution has been received by Licensor and+ subsequently incorporated within the Work.++ 2. Grant of Copyright License. Subject to the terms and conditions of+ this License, each Contributor hereby grants to You a perpetual,+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable+ copyright license to reproduce, prepare Derivative Works of,+ publicly display, publicly perform, sublicense, and distribute the+ Work and such Derivative Works in Source or Object form.++ 3. Grant of Patent License. Subject to the terms and conditions of+ this License, each Contributor hereby grants to You a perpetual,+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable+ (except as stated in this section) patent license to make, have made,+ use, offer to sell, sell, import, and otherwise transfer the Work,+ where such license applies only to those patent claims licensable+ by such Contributor that are necessarily infringed by their+ Contribution(s) alone or by combination of their Contribution(s)+ with the Work to which such Contribution(s) was submitted. If You+ institute patent litigation against any entity (including a+ cross-claim or counterclaim in a lawsuit) alleging that the Work+ or a Contribution incorporated within the Work constitutes direct+ or contributory patent infringement, then any patent licenses+ granted to You under this License for that Work shall terminate+ as of the date such litigation is filed.++ 4. Redistribution. You may reproduce and distribute copies of the+ Work or Derivative Works thereof in any medium, with or without+ modifications, and in Source or Object form, provided that You+ meet the following conditions:++ (a) You must give any other recipients of the Work or+ Derivative Works a copy of this License; and++ (b) You must cause any modified files to carry prominent notices+ stating that You changed the files; and++ (c) You must retain, in the Source form of any Derivative Works+ that You distribute, all copyright, patent, trademark, and+ attribution notices from the Source form of the Work,+ excluding those notices that do not pertain to any part of+ the Derivative Works; and++ (d) If the Work includes a "NOTICE" text file as part of its+ distribution, then any Derivative Works that You distribute must+ include a readable copy of the attribution notices contained+ within such NOTICE file, excluding those notices that do not+ pertain to any part of the Derivative Works, in at least one+ of the following places: within a NOTICE text file distributed+ as part of the Derivative Works; within the Source form or+ documentation, if provided along with the Derivative Works; or,+ within a display generated by the Derivative Works, if and+ wherever such third-party notices normally appear. The contents+ of the NOTICE file are for informational purposes only and+ do not modify the License. You may add Your own attribution+ notices within Derivative Works that You distribute, alongside+ or as an addendum to the NOTICE text from the Work, provided+ that such additional attribution notices cannot be construed+ as modifying the License.++ You may add Your own copyright statement to Your modifications and+ may provide additional or different license terms and conditions+ for use, reproduction, or distribution of Your modifications, or+ for any such Derivative Works as a whole, provided Your use,+ reproduction, and distribution of the Work otherwise complies with+ the conditions stated in this License.++ 5. Submission of Contributions. Unless You explicitly state otherwise,+ any Contribution intentionally submitted for inclusion in the Work+ by You to the Licensor shall be under the terms and conditions of+ this License, without any additional terms or conditions.+ Notwithstanding the above, nothing herein shall supersede or modify+ the terms of any separate license agreement you may have executed+ with Licensor regarding such Contributions.++ 6. Trademarks. This License does not grant permission to use the trade+ names, trademarks, service marks, or product names of the Licensor,+ except as required for reasonable and customary use in describing the+ origin of the Work and reproducing the content of the NOTICE file.++ 7. Disclaimer of Warranty. Unless required by applicable law or+ agreed to in writing, Licensor provides the Work (and each+ Contributor provides its Contributions) on an "AS IS" BASIS,+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or+ implied, including, without limitation, any warranties or conditions+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A+ PARTICULAR PURPOSE. You are solely responsible for determining the+ appropriateness of using or redistributing the Work and assume any+ risks associated with Your exercise of permissions under this License.++ 8. Limitation of Liability. In no event and under no legal theory,+ whether in tort (including negligence), contract, or otherwise,+ unless required by applicable law (such as deliberate and grossly+ negligent acts) or agreed to in writing, shall any Contributor be+ liable to You for damages, including any direct, indirect, special,+ incidental, or consequential damages of any character arising as a+ result of this License or out of the use or inability to use the+ Work (including but not limited to damages for loss of goodwill,+ work stoppage, computer failure or malfunction, or any and all+ other commercial damages or losses), even if such Contributor+ has been advised of the possibility of such damages.++ 9. Accepting Warranty or Additional Liability. While redistributing+ the Work or Derivative Works thereof, You may choose to offer,+ and charge a fee for, acceptance of support, warranty, indemnity,+ or other liability obligations and/or rights consistent with this+ License. However, in accepting such obligations, You may act only+ on Your own behalf and on Your sole responsibility, not on behalf+ of any other Contributor, and only if You agree to indemnify,+ defend, and hold each Contributor harmless for any liability+ incurred by, or claims asserted against, such Contributor by reason+ of your accepting any such warranty or additional liability.++ END OF TERMS AND CONDITIONS++ APPENDIX: How to apply the Apache License to your work.++ To apply the Apache License to your work, attach the following+ boilerplate notice, with the fields enclosed by brackets "[]"+ replaced with your own identifying information. (Don't include+ the brackets!) The text should be enclosed in the appropriate+ comment syntax for the file format. We also recommend that a+ file or class name and description of purpose be included on the+ same "printed page" as the copyright notice for easier+ identification within third-party archives.++ Copyright [2013] [[email protected]]++ Licensed under the Apache License, Version 2.0 (the "License");+ you may not use this file except in compliance with the License.+ You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++ Unless required by applicable law or agreed to in writing, software+ distributed under the License is distributed on an "AS IS" BASIS,+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ See the License for the specific language governing permissions and+ limitations under the License.diff --git a/src/main/java/io/github/hectorvent/floci/core/common/docker/DockerClientProducer.java b/src/main/java/io/github/hectorvent/floci/core/common/docker/DockerClientProducer.javaindex b206bc4d55..42864bca72 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/docker/DockerClientProducer.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/docker/DockerClientProducer.java@@ -9,7 +9,6 @@ import com.github.dockerjava.core.DefaultDockerClientConfig;import com.github.dockerjava.core.DockerClientImpl;import com.github.dockerjava.core.SSLConfig;import com.github.dockerjava.core.util.CertificateUtils;-import com.github.dockerjava.httpclient5.ApacheDockerHttpClient;import com.github.dockerjava.transport.DockerHttpClient;import jakarta.enterprise.context.ApplicationScoped;import jakarta.enterprise.inject.Produces;@@ -493,8 +492,8 @@ public class DockerClientProducer {wrapForRole(newHttpClient(clientConfig, maxConnections), role));}- static ApacheDockerHttpClient newHttpClient(DefaultDockerClientConfig clientConfig, int maxConnections) {- return new ApacheDockerHttpClient.Builder()+ static FlociDockerHttpClient newHttpClient(DefaultDockerClientConfig clientConfig, int maxConnections) {+ return new FlociDockerHttpClient.Builder().dockerHost(clientConfig.getDockerHost()).sslConfig(clientConfig.getSSLConfig()).maxConnections(maxConnections)diff --git a/src/main/java/io/github/hectorvent/floci/core/common/docker/FlociDockerHttpClient.java b/src/main/java/io/github/hectorvent/floci/core/common/docker/FlociDockerHttpClient.javanew file mode 100644index 0000000000..fb5260a9cf--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/core/common/docker/FlociDockerHttpClient.java@@ -0,0 +1,283 @@+/*+ * Adapted from docker-java 3.7.1, docker-java-transport-httpclient5,+ * com.github.dockerjava.httpclient5.ApacheDockerHttpClient and ApacheDockerHttpClientImpl.+ * Copyright docker-java contributors, licensed under the Apache License, Version 2.0+ * (http://www.apache.org/licenses/LICENSE-2.0). Changes: one Floci-owned class with a builder,+ * JBoss Logging, switch expressions; the pool, socket and request settings are unchanged.+ */+package io.github.hectorvent.floci.core.common.docker;++import com.github.dockerjava.transport.DockerHttpClient;+import com.github.dockerjava.transport.NamedPipeSocket;+import com.github.dockerjava.transport.SSLConfig;+import com.github.dockerjava.transport.UnixSocket;+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.impl.DefaultSchemePortResolver;+import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;+import org.apache.hc.client5.http.impl.classic.HttpClients;+import org.apache.hc.client5.http.impl.io.DefaultHttpClientConnectionOperator;+import org.apache.hc.client5.http.impl.io.ManagedHttpClientConnectionFactory;+import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;+import org.apache.hc.client5.http.io.HttpClientConnectionOperator;+import org.apache.hc.client5.http.ssl.DefaultClientTlsStrategy;+import org.apache.hc.client5.http.ssl.TlsSocketStrategy;+import org.apache.hc.core5.http.ClassicHttpResponse;+import org.apache.hc.core5.http.ConnectionClosedException;+import org.apache.hc.core5.http.ContentLengthStrategy;+import org.apache.hc.core5.http.Header;+import org.apache.hc.core5.http.HttpException;+import org.apache.hc.core5.http.HttpHeaders;+import org.apache.hc.core5.http.HttpHost;+import org.apache.hc.core5.http.HttpMessage;+import org.apache.hc.core5.http.NameValuePair;+import org.apache.hc.core5.http.impl.DefaultContentLengthStrategy;+import org.apache.hc.core5.http.io.SocketConfig;+import org.apache.hc.core5.http.io.entity.ByteArrayEntity;+import org.apache.hc.core5.http.io.entity.EmptyInputStream;+import org.apache.hc.core5.http.io.entity.InputStreamEntity;+import org.apache.hc.core5.http.protocol.HttpContext;+import org.apache.hc.core5.http.protocol.HttpCoreContext;+import org.apache.hc.core5.net.URIAuthority;+import org.apache.hc.core5.util.TimeValue;+import org.apache.hc.core5.util.Timeout;+import org.jboss.logging.Logger;++import javax.net.ssl.SSLContext;+import java.io.IOException;+import java.io.InputStream;+import java.net.Socket;+import java.net.URI;+import java.time.Duration;+import java.util.List;+import java.util.Map;+import java.util.Objects;+import java.util.concurrent.TimeUnit;+import java.util.stream.Collectors;+import java.util.stream.Stream;++/**+ * Floci's own Docker HTTP transport over httpclient5: the same transport docker-java's+ * {@code ApacheDockerHttpClient} builds, owned here so Floci can set what that builder does not+ * expose (idle-connection validation and eviction, the connection-lease timeout). It currently+ * applies exactly docker-java's settings: unix, npipe and tcp hosts, TLS from the SSL config, a pool+ * of {@code maxConnections} for one route, no socket read timeout on the pool ({@code SO_TIMEOUT} 0),+ * the request's response timeout, no stale-connection validation, and hijacked exec/attach upgrades+ * through {@link HijackingHttpRequestExecutor}.+ */+public final class FlociDockerHttpClient implements DockerHttpClient {++ private final CloseableHttpClient httpClient;+ private final HttpHost host;+ private final String pathPrefix;++ private FlociDockerHttpClient(URI dockerHost, SSLConfig sslConfig, int maxConnections,+ Duration connectionTimeout, Duration responseTimeout) {+ SSLContext sslContext;+ try {+ sslContext = sslConfig != null ? sslConfig.getSSLContext() : null;+ } catch (Exception e) {+ throw new RuntimeException(e);+ }+ HttpClientConnectionOperator connectionOperator = createConnectionOperator(dockerHost, sslContext);++ host = switch (dockerHost.getScheme()) {+ case "unix", "npipe" -> new HttpHost(dockerHost.getScheme(), "localhost", 2375);+ case "tcp" -> new HttpHost(sslContext != null ? "https" : "http", dockerHost.getHost(), dockerHost.getPort());+ default -> throw new IllegalArgumentException("Unsupported protocol scheme: " + dockerHost);+ };+ String rawPath = "tcp".equals(dockerHost.getScheme()) ? dockerHost.getRawPath() : "";+ pathPrefix = rawPath.endsWith("/") ? rawPath.substring(0, rawPath.length() - 1) : rawPath;++ PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(+ connectionOperator, null, null, null,+ new ManagedHttpClientConnectionFactory(null, null, null, null,+ FlociDockerHttpClient::determineLength, null));+ // A pooled socket must never time out by itself: follow streams stay silent for as long as+ // the container is quiet. Per-request timeouts come from the RequestConfig below.+ // See https://github.com/docker-java/docker-java/pull/1590#issuecomment-870581289+ connectionManager.setDefaultSocketConfig(SocketConfig.copy(SocketConfig.DEFAULT)+ .setSoTimeout(Timeout.ZERO_MILLISECONDS)+ .build());+ connectionManager.setMaxTotal(maxConnections);+ connectionManager.setDefaultMaxPerRoute(maxConnections);+ connectionManager.setDefaultConnectionConfig(ConnectionConfig.custom()+ .setValidateAfterInactivity(TimeValue.NEG_ONE_SECOND)+ .setConnectTimeout(connectionTimeout != null+ ? Timeout.of(connectionTimeout.toNanos(), TimeUnit.NANOSECONDS) : null)+ .build());++ httpClient = HttpClients.custom()+ .setRequestExecutor(new HijackingHttpRequestExecutor(null))+ .setConnectionManager(connectionManager)+ .setDefaultRequestConfig(RequestConfig.custom()+ .setResponseTimeout(responseTimeout != null+ ? Timeout.of(responseTimeout.toNanos(), TimeUnit.NANOSECONDS) : null)+ .build())+ .disableConnectionState()+ .build();+ }++ /** A {@code Transfer-Encoding: identity} body is read to the end of the stream, not by length. */+ private static long determineLength(HttpMessage message) throws HttpException {+ Header transferEncoding = message.getFirstHeader(HttpHeaders.TRANSFER_ENCODING);+ if (transferEncoding != null && "identity".equalsIgnoreCase(transferEncoding.getValue())) {+ return ContentLengthStrategy.UNDEFINED;+ }+ return DefaultContentLengthStrategy.INSTANCE.determineLength(message);+ }++ private static HttpClientConnectionOperator createConnectionOperator(URI dockerHost, SSLContext sslContext) {+ String scheme = dockerHost.getScheme();+ String path = dockerHost.getPath();+ TlsSocketStrategy tlsSocketStrategy = sslContext != null+ ? new DefaultClientTlsStrategy(sslContext) : DefaultClientTlsStrategy.createSystemDefault();+ return new DefaultHttpClientConnectionOperator(+ socksProxy -> {+ if ("unix".equalsIgnoreCase(scheme)) {+ return UnixSocket.get(path);+ }+ if ("npipe".equalsIgnoreCase(scheme)) {+ return new NamedPipeSocket(path);+ }+ return socksProxy == null ? new Socket() : new Socket(socksProxy);+ },+ DefaultSchemePortResolver.INSTANCE,+ SystemDefaultDnsResolver.INSTANCE,+ name -> "https".equalsIgnoreCase(name) ? tlsSocketStrategy : null);+ }++ @Override+ public Response execute(Request request) {+ HttpContext context = new HttpCoreContext();+ HttpUriRequestBase httpRequest =+ new HttpUriRequestBase(request.method(), URI.create(pathPrefix + request.path()));+ httpRequest.setScheme(host.getSchemeName());+ httpRequest.setAuthority(new URIAuthority(host.getHostName(), host.getPort()));++ request.headers().forEach(httpRequest::addHeader);++ byte[] bodyBytes = request.bodyBytes();+ if (bodyBytes != null) {+ httpRequest.setEntity(new ByteArrayEntity(bodyBytes, null));+ } else if (request.body() != null) {+ httpRequest.setEntity(new InputStreamEntity(request.body(), null));+ }++ if (request.hijackedInput() != null) {+ context.setAttribute(HijackingHttpRequestExecutor.HIJACKED_INPUT_ATTRIBUTE, request.hijackedInput());+ httpRequest.setHeader("Upgrade", "tcp");+ httpRequest.setHeader("Connection", "Upgrade");+ }++ try {+ ClassicHttpResponse response = httpClient.executeOpen(host, httpRequest, context);+ return new FlociResponse(httpRequest, response);+ } catch (IOException e) {+ throw new RuntimeException(e);+ }+ }++ @Override+ public void close() throws IOException {+ httpClient.close();+ }++ /** Builds a client; mirrors docker-java's {@code ApacheDockerHttpClient.Builder}. */+ public static final class Builder {++ private URI dockerHost;+ private SSLConfig sslConfig;+ private int maxConnections = Integer.MAX_VALUE;+ private Duration connectionTimeout;+ private Duration responseTimeout;++ public Builder dockerHost(URI value) {+ this.dockerHost = Objects.requireNonNull(value, "dockerHost");+ return this;+ }++ public Builder sslConfig(SSLConfig value) {+ this.sslConfig = value;+ return this;+ }++ public Builder maxConnections(int value) {+ this.maxConnections = value;+ return this;+ }++ public Builder connectionTimeout(Duration value) {+ this.connectionTimeout = value;+ return this;+ }++ public Builder responseTimeout(Duration value) {+ this.responseTimeout = value;+ return this;+ }++ public FlociDockerHttpClient build() {+ Objects.requireNonNull(dockerHost, "dockerHost");+ return new FlociDockerHttpClient(dockerHost, sslConfig, maxConnections, connectionTimeout, responseTimeout);+ }+ }++ private static final class FlociResponse implements Response {++ private static final Logger LOG = Logger.getLogger(FlociResponse.class);++ private final HttpUriRequestBase request;+ private final ClassicHttpResponse response;++ FlociResponse(HttpUriRequestBase request, ClassicHttpResponse response) {+ this.request = request;+ this.response = response;+ }++ @Override+ public int getStatusCode() {+ return response.getCode();+ }++ @Override+ public Map<String, List<String>> getHeaders() {+ return Stream.of(response.getHeaders()).collect(Collectors.groupingBy(+ NameValuePair::getName,+ Collectors.mapping(NameValuePair::getValue, Collectors.toList())));+ }++ @Override+ public String getHeader(String name) {+ Header header = response.getFirstHeader(name);+ return header != null ? header.getValue() : null;+ }++ @Override+ public InputStream getBody() {+ try {+ return response.getEntity() != null ? response.getEntity().getContent() : EmptyInputStream.INSTANCE;+ } catch (IOException e) {+ throw new RuntimeException(e);+ }+ }++ @Override+ public void close() {+ try {+ request.abort();+ } catch (Exception e) {+ LOG.debugv(e, "Failed to abort the Docker request");+ }+ try {+ response.close();+ } catch (ConnectionClosedException e) {+ LOG.tracev(e, "Docker response already closed");+ } catch (Exception e) {+ LOG.debugv(e, "Failed to close the Docker response");+ }+ }+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/core/common/docker/HijackingHttpRequestExecutor.java b/src/main/java/io/github/hectorvent/floci/core/common/docker/HijackingHttpRequestExecutor.javanew file mode 100644index 0000000000..66f179e74b--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/core/common/docker/HijackingHttpRequestExecutor.java@@ -0,0 +1,150 @@+/*+ * Adapted from docker-java 3.7.1, docker-java-transport-httpclient5,+ * com.github.dockerjava.httpclient5.HijackingHttpRequestExecutor.+ * Copyright docker-java contributors, licensed under the Apache License, Version 2.0+ * (http://www.apache.org/licenses/LICENSE-2.0). Changes: moved into Floci's package, JBoss+ * Logging conventions; the upgrade logic is unchanged.+ */+package io.github.hectorvent.floci.core.common.docker;++import org.apache.hc.core5.http.ClassicHttpRequest;+import org.apache.hc.core5.http.ClassicHttpResponse;+import org.apache.hc.core5.http.ConnectionReuseStrategy;+import org.apache.hc.core5.http.HttpException;+import org.apache.hc.core5.http.HttpHeaders;+import org.apache.hc.core5.http.HttpStatus;+import org.apache.hc.core5.http.ProtocolException;+import org.apache.hc.core5.http.ProtocolVersion;+import org.apache.hc.core5.http.impl.io.HttpRequestExecutor;+import org.apache.hc.core5.http.io.HttpClientConnection;+import org.apache.hc.core5.http.io.HttpResponseInformationCallback;+import org.apache.hc.core5.http.io.entity.AbstractHttpEntity;+import org.apache.hc.core5.http.message.BasicClassicHttpRequest;+import org.apache.hc.core5.http.message.StatusLine;+import org.apache.hc.core5.http.protocol.HttpContext;+import org.apache.hc.core5.http.protocol.HttpCoreContext;+import org.apache.hc.core5.io.Closer;++import java.io.IOException;+import java.io.InputStream;+import java.io.OutputStream;+import java.util.Objects;++/**+ * Executes a hijacked request (exec and attach with stdin): sends the upgrade, expects+ * {@code 101 Switching Protocols}, then streams the caller's input on a daemon thread while the+ * response body is read as the output stream. Every other request goes through the stock executor.+ */+class HijackingHttpRequestExecutor extends HttpRequestExecutor {++ static final String HIJACKED_INPUT_ATTRIBUTE = "com.github.docker-java.hijackedInput";++ HijackingHttpRequestExecutor(ConnectionReuseStrategy connectionReuseStrategy) {+ super(connectionReuseStrategy);+ }++ @Override+ public ClassicHttpResponse execute(ClassicHttpRequest request, HttpClientConnection conn,+ HttpResponseInformationCallback informationCallback,+ HttpContext context) throws IOException, HttpException {+ Objects.requireNonNull(request, "HTTP request");+ Objects.requireNonNull(conn, "Client connection");+ Objects.requireNonNull(context, "HTTP context");++ InputStream hijackedInput = (InputStream) context.getAttribute(HIJACKED_INPUT_ATTRIBUTE);+ if (hijackedInput != null) {+ return executeHijacked(request, conn, (HttpCoreContext) context, hijackedInput);+ }+ return super.execute(request, conn, informationCallback, context);+ }++ private ClassicHttpResponse executeHijacked(ClassicHttpRequest request, HttpClientConnection conn,+ HttpCoreContext context, InputStream hijackedInput)+ throws HttpException, IOException {+ try {+ context.setSSLSession(conn.getSSLSession());+ context.setEndpointDetails(conn.getEndpointDetails());+ ProtocolVersion transportVersion = request.getVersion();+ if (transportVersion != null) {+ context.setProtocolVersion(transportVersion);+ }++ conn.sendRequestHeader(request);+ conn.sendRequestEntity(request);+ conn.flush();++ ClassicHttpResponse response = conn.receiveResponseHeader();+ if (response.getCode() != HttpStatus.SC_SWITCHING_PROTOCOLS) {+ conn.terminateRequest(request);+ throw new ProtocolException("Expected 101 Switching Protocols, got: " + new StatusLine(response));+ }++ Thread thread = new Thread(() -> {+ try {+ BasicClassicHttpRequest fakeRequest = new BasicClassicHttpRequest("POST", "/");+ fakeRequest.setHeader(HttpHeaders.CONTENT_LENGTH, Long.MAX_VALUE);+ fakeRequest.setEntity(new HijackedEntity(hijackedInput));+ conn.sendRequestEntity(fakeRequest);+ } catch (Exception e) {+ throw new RuntimeException(e);+ }+ });+ thread.setName("docker-java-httpclient5-hijacking-stream-" + System.identityHashCode(request));+ thread.setDaemon(true);+ thread.start();++ // The upgraded stream is read as an ordinary response body: 101 becomes 200.+ response.setCode(200);+ conn.receiveResponseEntity(response);+ return response;+ } catch (HttpException | IOException | RuntimeException e) {+ Closer.closeQuietly(conn);+ throw e;+ }+ }++ private static final class HijackedEntity extends AbstractHttpEntity {++ private final InputStream inStream;++ HijackedEntity(InputStream inStream) {+ super((String) null, null, false);+ this.inStream = inStream;+ }++ @Override+ public void writeTo(OutputStream outStream) throws IOException {+ byte[] buffer = new byte[1024];+ int read;+ while ((read = inStream.read(buffer)) != -1) {+ outStream.write(buffer, 0, read);+ outStream.flush();+ }+ }++ @Override+ public InputStream getContent() {+ return inStream;+ }++ @Override+ public boolean isStreaming() {+ return true;+ }++ @Override+ public boolean isRepeatable() {+ return false;+ }++ @Override+ public void close() throws IOException {+ inStream.close();+ }++ @Override+ public long getContentLength() {+ return -1;+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/core/common/docker/DockerClientProducerTest.java b/src/test/java/io/github/hectorvent/floci/core/common/docker/DockerClientProducerTest.javaindex f637f781b4..e2add9ad28 100644--- a/src/test/java/io/github/hectorvent/floci/core/common/docker/DockerClientProducerTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/common/docker/DockerClientProducerTest.java@@ -4,7 +4,6 @@ import com.github.dockerjava.api.DockerClient;import com.github.dockerjava.api.async.ResultCallback;import com.github.dockerjava.api.model.Frame;import com.github.dockerjava.core.DefaultDockerClientConfig;-import com.github.dockerjava.httpclient5.ApacheDockerHttpClient;import io.github.hectorvent.floci.config.EmulatorConfig;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;@@ -753,7 +752,7 @@ class DockerClientProducerTest {.withDockerTlsVerify(false).build();- try (ApacheDockerHttpClient client = DockerClientProducer.newHttpClient(plainConfig, 10)) {+ try (FlociDockerHttpClient client = DockerClientProducer.newHttpClient(plainConfig, 10)) {assertNull(plainConfig.getSSLConfig(), "a config without TLS verify carries no SSL config");assertEquals("tcp://127.0.0.1:2375", plainConfig.getDockerHost().toString());}