fix:"修复媒体下载DNS重绑定并隔离出站传输"
This commit is contained in:
1 parent
926aa64ba3
commit
32f6f67b9f
15 files changed
+791
-56
No files matched your search
+5
@@ -20,6 +20,11 @@ class ModuleDependencyTest {
|
||||
assertTrue(Files.exists(root.resolve("task/TaskSettlementService.java")));
|
||||
disallow(root.resolve("task/TaskSettlementService.java"), List.of("java.net.http", "AsyncProviderClient", "OpenAiCompatibleProvider"));
|
||||
}
|
||||
@Test void mediaInputDoesNotOwnCredentialsRoutingOrBilling() throws Exception {
|
||||
disallow(root.resolve("provider/media"), List.of(".gateway.", ".wallet.", ".auth.", ".task.",
|
||||
".provider.credentials", "org.springframework.jdbc", ".security.SecretCipher", "java.net.http.HttpClient"));
|
||||
assertFalse(Files.readString(root.resolve("task/AsyncProviderClient.java")).contains("InetAddress"), "DNS policy belongs to the media boundary");
|
||||
}
|
||||
private void disallow(Path path, List<String> forbidden) throws Exception {
|
||||
assertTrue(Files.exists(path), "Expected source boundary: " + path);
|
||||
try (var paths = Files.isDirectory(path) ? Files.walk(path) : java.util.stream.Stream.of(path)) {
|
||||
|
||||
+58
@@ -0,0 +1,58 @@
|
||||
package com.moyi.controlplane.provider.media;
|
||||
|
||||
import com.moyi.controlplane.common.ApiException;
|
||||
import com.moyi.controlplane.provider.transport.BoundedHttpTransport;
|
||||
import com.moyi.controlplane.provider.transport.PinnedHttpsTransport;
|
||||
import java.net.URI;
|
||||
import java.net.http.HttpHeaders;
|
||||
import java.time.Duration;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.params.ParameterizedTest;
|
||||
import org.junit.jupiter.params.provider.CsvSource;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.ArgumentMatchers.*;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
class MediaDownloaderTest {
|
||||
private final PinnedHttpsTransport transport = mock(PinnedHttpsTransport.class);
|
||||
private final MediaDownloader downloader = new MediaDownloader(transport, host -> { throw new AssertionError("Unexpected network"); });
|
||||
|
||||
@Test void normalizesImagesAndPreservesBoundedTransportContract() throws Exception {
|
||||
byte[] bytes = {1, 2, 3};
|
||||
when(transport.get(any(), any(), any(), anyInt())).thenReturn(response(200, "IMAGE/PNG; charset=utf-8", bytes));
|
||||
var image = downloader.download("https://media.test/a?signature=synthetic");
|
||||
assertArrayEquals(bytes, image.bytes()); assertEquals("image/png", image.contentType()); assertEquals("input.png", image.filename());
|
||||
verify(transport).get(eq(URI.create("https://media.test/a?signature=synthetic")), any(), eq(Duration.ofSeconds(15)), eq(8 * 1024 * 1024));
|
||||
assertFalse(image.toString().contains("synthetic"));
|
||||
}
|
||||
|
||||
@Test void invalidUrlsFailBeforeTransport() {
|
||||
assertEquals("INVALID_MEDIA_URL", assertThrows(ApiException.class, () -> downloader.download("https://user:secret@media.test/a")).getCode());
|
||||
verifyNoInteractions(transport);
|
||||
}
|
||||
|
||||
@ParameterizedTest @CsvSource({"BODY_TOO_LARGE,MEDIA_TOO_LARGE", "INVALID_ADDRESS,INVALID_MEDIA_URL", "TIMEOUT,MEDIA_FETCH_FAILED", "INTERRUPTED,MEDIA_FETCH_FAILED", "BUSY,MEDIA_FETCH_FAILED", "IO,MEDIA_FETCH_FAILED"})
|
||||
void transportFailuresExposeOnlySafeDomainCodes(BoundedHttpTransport.Reason reason, String code) throws Exception {
|
||||
var failure = mock(BoundedHttpTransport.Failure.class); when(failure.reason()).thenReturn(reason);
|
||||
when(transport.get(any(), any(), any(), anyInt())).thenThrow(failure);
|
||||
var error = assertThrows(ApiException.class, () -> downloader.download("https://media.test/a?signature=private"));
|
||||
assertEquals(code, error.getCode()); assertFalse(error.getMessage().contains("private")); assertNull(error.getCause());
|
||||
}
|
||||
|
||||
@ParameterizedTest @CsvSource({"302,image/png,MEDIA_FETCH_FAILED", "404,image/png,MEDIA_FETCH_FAILED", "200,text/html,MEDIA_TYPE_UNSUPPORTED", "200,image/invalid:type,MEDIA_TYPE_UNSUPPORTED"})
|
||||
void redirectsErrorsAndUnsupportedTypesAreRejected(int status, String type, String code) throws Exception {
|
||||
when(transport.get(any(), any(), any(), anyInt())).thenReturn(response(status, type, new byte[] {1}));
|
||||
assertEquals(code, assertThrows(ApiException.class, () -> downloader.download("https://media.test/a")).getCode());
|
||||
}
|
||||
|
||||
@Test void emptyBodyIsRejected() throws Exception {
|
||||
when(transport.get(any(), any(), any(), anyInt())).thenReturn(response(200, "image/png", new byte[0]));
|
||||
assertEquals("MEDIA_TOO_LARGE", assertThrows(ApiException.class, () -> downloader.download("https://media.test/a")).getCode());
|
||||
}
|
||||
|
||||
private BoundedHttpTransport.Response response(int status, String type, byte[] body) {
|
||||
return new BoundedHttpTransport.Response(status, HttpHeaders.of(Map.of("Content-Type", List.of(type)), (key, value) -> true), body);
|
||||
}
|
||||
}
|
||||
+65
@@ -0,0 +1,65 @@
|
||||
package com.moyi.controlplane.provider.media;
|
||||
|
||||
import com.moyi.controlplane.provider.transport.PinnedHttpsTransport;
|
||||
import java.net.InetAddress;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.params.ParameterizedTest;
|
||||
import org.junit.jupiter.params.provider.ValueSource;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class PublicMediaAddressPolicyTest {
|
||||
private final PublicMediaAddressPolicy policy = new PublicMediaAddressPolicy();
|
||||
|
||||
@ParameterizedTest
|
||||
@ValueSource(strings = {
|
||||
"0.0.0.0", "0.255.255.255", "10.0.0.1", "127.0.0.1", "127.255.255.254",
|
||||
"100.64.0.1", "100.127.255.254", "169.254.169.254", "172.16.0.1", "172.31.255.254",
|
||||
"192.0.0.1", "192.0.0.9", "192.0.2.1", "192.88.99.1", "192.168.1.1",
|
||||
"198.18.0.1", "198.19.255.254", "198.51.100.1", "203.0.113.1", "224.0.0.1",
|
||||
"239.255.255.255", "240.0.0.1", "255.255.255.255", "168.63.129.16",
|
||||
"::", "::1", "::127.0.0.1", "::ffff:127.0.0.1", "::ffff:169.254.169.254",
|
||||
"fc00::1", "fd00::1", "fe80::1", "fec0::1", "ff02::1", "64:ff9b::a00:1", "64:ff9b:1::1",
|
||||
"100::1", "2001::1", "2001:1ff:ffff::1", "2001:2::1", "2001:20::1", "2001:db8::1",
|
||||
"2002:7f00:1::1", "2002:0808:0808::1", "3ffe::1", "3fff::1", "3fff:fff:ffff::1", "4000::1"
|
||||
})
|
||||
void rejectsNonGlobalSpecialAndTranslationTargets(String literal) throws Exception {
|
||||
InetAddress address = InetAddress.getByName(literal);
|
||||
assertFalse(policy.isPublic(address), literal);
|
||||
assertThrows(PinnedHttpsTransport.AddressRejectedException.class, () -> policy.requirePublic(new InetAddress[] {address}));
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@ValueSource(strings = {"1.1.1.1", "8.8.8.8", "100.63.255.254", "100.128.0.1", "172.15.255.254", "172.32.0.1",
|
||||
"192.0.1.1", "198.17.255.254", "198.20.0.1", "223.255.255.254", "2606:4700:4700::1111", "2001:4860:4860::8888", "3fff:1000::1"})
|
||||
void permitsOrdinaryGlobalAddressesWithoutMakingInternetRequests(String literal) throws Exception {
|
||||
var address = InetAddress.getByName(literal);
|
||||
assertTrue(policy.isPublic(address), literal);
|
||||
assertArrayEquals(new InetAddress[] {address}, policy.requirePublic(new InetAddress[] {address}));
|
||||
}
|
||||
|
||||
@Test void rejectsTheWholeMixedAnswerSetInEitherOrder() throws Exception {
|
||||
var external = InetAddress.getByName("8.8.8.8");
|
||||
var internal = InetAddress.getByName("fd00::1");
|
||||
assertThrows(PinnedHttpsTransport.AddressRejectedException.class, () -> policy.requirePublic(new InetAddress[] {external, internal}));
|
||||
assertThrows(PinnedHttpsTransport.AddressRejectedException.class, () -> policy.requirePublic(new InetAddress[] {internal, external}));
|
||||
assertThrows(PinnedHttpsTransport.AddressRejectedException.class, () -> policy.requirePublic(new InetAddress[0]));
|
||||
assertThrows(PinnedHttpsTransport.AddressRejectedException.class, () -> policy.requirePublic(new InetAddress[] {null}));
|
||||
assertThrows(PinnedHttpsTransport.AddressRejectedException.class, () -> policy.requirePublic(new InetAddress[17]));
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@ValueSource(strings = {"http://example.test/a", "file:///etc/passwd", "data:image/png,a", "//example.test/a",
|
||||
"https://user:secret@example.test/a", "https://example.test/a#fragment", "https://example.test:0/a", "https://example.test:65536/a",
|
||||
"https://[fe80::1%25eth0]/a", "https://example.test\\@127.0.0.1/a", "https://example.test/%0d%0a/x\r\n", "https:///a", ""})
|
||||
void rejectsAmbiguousOrNonHttpsUris(String value) {
|
||||
var failure = assertThrows(IllegalArgumentException.class, () -> policy.requireUri(value));
|
||||
assertFalse(failure.getMessage().contains("secret"));
|
||||
assertNull(failure.getCause());
|
||||
}
|
||||
|
||||
@Test void permitsSignedHttpsUrlsAndExplicitHttpsPortsWithoutRewritingAuthority() {
|
||||
String value = "https://media.example.test:8443/a.png?signature=synthetic";
|
||||
assertEquals(value, policy.requireUri(value).toString());
|
||||
assertEquals("[2606:4700:4700::1111]", policy.requireUri("https://[2606:4700:4700::1111]/a").getHost());
|
||||
}
|
||||
}
|
||||
+279
@@ -0,0 +1,279 @@
|
||||
package com.moyi.controlplane.provider.transport;
|
||||
|
||||
import com.sun.net.httpserver.HttpsConfigurator;
|
||||
import com.sun.net.httpserver.HttpsServer;
|
||||
import java.net.InetAddress;
|
||||
import java.net.InetSocketAddress;
|
||||
import java.net.URI;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.security.KeyStore;
|
||||
import java.time.Duration;
|
||||
import java.util.concurrent.CountDownLatch;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.SynchronousQueue;
|
||||
import java.util.concurrent.ThreadPoolExecutor;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
import java.util.concurrent.atomic.AtomicReference;
|
||||
import javax.net.ssl.ExtendedSSLSession;
|
||||
import javax.net.ssl.KeyManagerFactory;
|
||||
import javax.net.ssl.SNIHostName;
|
||||
import javax.net.ssl.SSLContext;
|
||||
import javax.net.ssl.TrustManagerFactory;
|
||||
import org.junit.jupiter.api.AfterEach;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.io.TempDir;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class PinnedHttpsTransportTest {
|
||||
@TempDir static Path temporary;
|
||||
private static SSLContext serverTls, trustedTls;
|
||||
private HttpsServer server;
|
||||
private ExecutorService workers;
|
||||
private PinnedHttpsTransport transport;
|
||||
private final CountDownLatch release = new CountDownLatch(1);
|
||||
|
||||
@BeforeAll static void createEphemeralTestCertificate() throws Exception {
|
||||
// No committed key, no trust-all TLS: mint a .test certificate and trust only this test key.
|
||||
String password = java.util.UUID.randomUUID().toString();
|
||||
Path store = temporary.resolve("media-test.p12");
|
||||
var process = new ProcessBuilder(Path.of(System.getProperty("java.home"), "bin", "keytool").toString(),
|
||||
"-genkeypair", "-alias", "test", "-keyalg", "RSA", "-keysize", "2048", "-validity", "2",
|
||||
"-dname", "CN=media.test", "-ext", "SAN=dns:media.test", "-storetype", "PKCS12",
|
||||
"-keystore", store.toString(), "-storepass", password, "-keypass", password, "-noprompt")
|
||||
.redirectErrorStream(true).start();
|
||||
assertTrue(process.waitFor(15, TimeUnit.SECONDS));
|
||||
assertEquals(0, process.exitValue(), () -> "Unable to create ephemeral TLS fixture");
|
||||
var keys = KeyStore.getInstance("PKCS12");
|
||||
try (var input = Files.newInputStream(store)) { keys.load(input, password.toCharArray()); }
|
||||
var kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
|
||||
kmf.init(keys, password.toCharArray());
|
||||
serverTls = SSLContext.getInstance("TLS");
|
||||
serverTls.init(kmf.getKeyManagers(), null, null);
|
||||
var trust = KeyStore.getInstance(KeyStore.getDefaultType()); trust.load(null, null);
|
||||
trust.setCertificateEntry("test", keys.getCertificate("test"));
|
||||
var tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); tmf.init(trust);
|
||||
trustedTls = SSLContext.getInstance("TLS"); trustedTls.init(null, tmf.getTrustManagers(), null);
|
||||
}
|
||||
|
||||
@BeforeEach void setup() throws Exception {
|
||||
server = HttpsServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
|
||||
server.setHttpsConfigurator(new HttpsConfigurator(serverTls));
|
||||
workers = new ThreadPoolExecutor(0, 2, 5, TimeUnit.SECONDS, new SynchronousQueue<>(),
|
||||
runnable -> { var thread = new Thread(runnable, "test-pinned-get"); thread.setDaemon(true); return thread; });
|
||||
transport = new PinnedHttpsTransport(trustedTls, workers);
|
||||
}
|
||||
@AfterEach void cleanup() throws Exception {
|
||||
release.countDown(); workers.shutdownNow(); server.stop(0);
|
||||
assertTrue(workers.awaitTermination(3, TimeUnit.SECONDS));
|
||||
}
|
||||
private URI uri(String path) { return URI.create("https://media.test:" + server.getAddress().getPort() + path); }
|
||||
private InetAddress[] loopback(String host) throws java.io.IOException { return new InetAddress[] {InetAddress.getByName("127.0.0.1")}; }
|
||||
private BoundedHttpTransport.Response get(String path, long timeoutMs, int maxBytes) throws Exception {
|
||||
return transport.get(uri(path), this::loopback, Duration.ofMillis(timeoutMs), maxBytes);
|
||||
}
|
||||
|
||||
@Test void bindsDnsOnceWhilePreservingHostSniAndCredentialIsolation() throws Exception {
|
||||
var lookups = new AtomicInteger(); var host = new AtomicReference<String>(); var sni = new AtomicReference<String>();
|
||||
server.createContext("/", exchange -> {
|
||||
host.set(exchange.getRequestHeaders().getFirst("Host"));
|
||||
var session = (ExtendedSSLSession) ((com.sun.net.httpserver.HttpsExchange) exchange).getSSLSession();
|
||||
sni.set(((SNIHostName) session.getRequestedServerNames().getFirst()).getAsciiName());
|
||||
assertNull(exchange.getRequestHeaders().getFirst("Authorization"));
|
||||
assertNull(exchange.getRequestHeaders().getFirst("Cookie"));
|
||||
assertNull(exchange.getRequestHeaders().getFirst("Proxy-Authorization"));
|
||||
assertEquals("identity", exchange.getRequestHeaders().getFirst("Accept-Encoding"));
|
||||
exchange.getResponseHeaders().set("Content-Type", "image/png");
|
||||
byte[] bytes = "synthetic-image".getBytes(StandardCharsets.UTF_8); exchange.sendResponseHeaders(200, bytes.length);
|
||||
try (var output = exchange.getResponseBody()) { output.write(bytes); }
|
||||
}); server.start();
|
||||
var response = transport.get(uri("/?signature=synthetic-private-query"), target -> {
|
||||
assertEquals("media.test", target);
|
||||
if (lookups.incrementAndGet() != 1) throw new AssertionError("DNS was resolved twice");
|
||||
return loopback(target);
|
||||
}, Duration.ofSeconds(3), 1024);
|
||||
assertEquals(200, response.statusCode()); assertEquals(1, lookups.get());
|
||||
assertEquals("media.test:" + server.getAddress().getPort(), host.get()); assertEquals("media.test", sni.get());
|
||||
assertEquals("synthetic-image", new String(response.body(), StandardCharsets.UTF_8));
|
||||
assertFalse(response.toString().contains("synthetic"));
|
||||
}
|
||||
|
||||
@Test void aTrustedCertificateForAnotherHostnameStillFails() throws Exception {
|
||||
var calls = new AtomicInteger();
|
||||
server.createContext("/", exchange -> { calls.incrementAndGet(); exchange.sendResponseHeaders(200, -1); exchange.close(); }); server.start();
|
||||
URI wrong = URI.create("https://wrong.test:" + server.getAddress().getPort() + "/?signature=private");
|
||||
var failure = assertThrows(BoundedHttpTransport.Failure.class, () -> transport.get(wrong, this::loopback, Duration.ofSeconds(3), 1024));
|
||||
assertEquals(BoundedHttpTransport.Reason.IO, failure.reason()); assertEquals(0, calls.get());
|
||||
assertNull(failure.getCause()); assertFalse(failure.toString().contains("private"));
|
||||
}
|
||||
|
||||
@Test void theDefaultTrustStoreDoesNotAcceptOurSelfSignedTestCertificate() throws Exception {
|
||||
server.createContext("/", exchange -> { exchange.sendResponseHeaders(200, -1); exchange.close(); }); server.start();
|
||||
var strict = new PinnedHttpsTransport(org.apache.hc.core5.ssl.SSLContexts.createDefault(), workers);
|
||||
assertEquals(BoundedHttpTransport.Reason.IO, assertThrows(BoundedHttpTransport.Failure.class,
|
||||
() -> strict.get(uri("/"), this::loopback, Duration.ofSeconds(3), 1024)).reason());
|
||||
}
|
||||
|
||||
@Test void redirectsAreNeverFollowed() throws Exception {
|
||||
var calls = new AtomicInteger();
|
||||
server.createContext("/", exchange -> {
|
||||
calls.incrementAndGet(); exchange.getResponseHeaders().set("Location", "https://127.0.0.1/private");
|
||||
exchange.sendResponseHeaders(302, -1); exchange.close();
|
||||
}); server.start();
|
||||
assertEquals(302, get("/", 3000, 1024).statusCode()); assertEquals(1, calls.get());
|
||||
}
|
||||
|
||||
@Test void declaredOversizeDoesNotWaitForTheBodyOrDrainItOnClose() {
|
||||
server.createContext("/", exchange -> {
|
||||
exchange.sendResponseHeaders(200, 1_000_000);
|
||||
try { release.await(3, TimeUnit.SECONDS); } catch (InterruptedException error) { Thread.currentThread().interrupt(); }
|
||||
exchange.close();
|
||||
}); server.start();
|
||||
var failure = assertThrows(BoundedHttpTransport.Failure.class, () -> get("/", 2000, 8192));
|
||||
assertEquals(BoundedHttpTransport.Reason.BODY_TOO_LARGE, failure.reason()); assertEquals(200, failure.observedStatus());
|
||||
}
|
||||
|
||||
@Test void chunkedOversizeIsStoppedDuringRead() {
|
||||
server.createContext("/", exchange -> {
|
||||
exchange.sendResponseHeaders(200, 0);
|
||||
try (var output = exchange.getResponseBody()) { for (int i = 0; i < 100; i++) output.write(new byte[4096]); }
|
||||
catch (java.io.IOException expectedAfterCancellation) { }
|
||||
}); server.start();
|
||||
assertEquals(BoundedHttpTransport.Reason.BODY_TOO_LARGE, assertThrows(BoundedHttpTransport.Failure.class, () -> get("/", 3000, 8192)).reason());
|
||||
}
|
||||
|
||||
@Test void deadlineIncludesSlowResponseBodyAndRestoresWorkerCapacity() throws Exception {
|
||||
var arrived = new CountDownLatch(1);
|
||||
server.createContext("/", exchange -> {
|
||||
exchange.sendResponseHeaders(200, 0);
|
||||
try (var output = exchange.getResponseBody()) {
|
||||
output.write('x'); output.flush(); arrived.countDown();
|
||||
try { release.await(5, TimeUnit.SECONDS); } catch (InterruptedException error) { Thread.currentThread().interrupt(); }
|
||||
} catch (java.io.IOException expectedAfterCancellation) { }
|
||||
}); server.start();
|
||||
long start = System.nanoTime();
|
||||
var failure = assertThrows(BoundedHttpTransport.Failure.class, () -> get("/", 1000, 8192));
|
||||
assertEquals(BoundedHttpTransport.Reason.TIMEOUT, failure.reason()); assertEquals(200, failure.observedStatus());
|
||||
assertEquals(0, arrived.getCount()); assertTrue(TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start) < 2500);
|
||||
workers.shutdown(); assertTrue(workers.awaitTermination(2, TimeUnit.SECONDS));
|
||||
}
|
||||
|
||||
@Test void lateDnsResolutionCannotStartHttpAfterTheDeadline() throws Exception {
|
||||
var resolving = new CountDownLatch(1); var finished = new CountDownLatch(1); var calls = new AtomicInteger();
|
||||
server.createContext("/", exchange -> { calls.incrementAndGet(); exchange.sendResponseHeaders(200, -1); exchange.close(); }); server.start();
|
||||
var failure = assertThrows(BoundedHttpTransport.Failure.class, () -> transport.get(uri("/"), host -> {
|
||||
resolving.countDown();
|
||||
boolean interrupted = false;
|
||||
while (release.getCount() != 0) try { release.await(1, TimeUnit.SECONDS); }
|
||||
catch (InterruptedException ignoredForSimulatedNativeResolver) { interrupted = true; }
|
||||
if (interrupted) Thread.currentThread().interrupt();
|
||||
finished.countDown(); return loopback(host);
|
||||
}, Duration.ofMillis(200), 1024));
|
||||
assertEquals(BoundedHttpTransport.Reason.TIMEOUT, failure.reason()); assertEquals(0, resolving.getCount());
|
||||
release.countDown(); assertTrue(finished.await(2, TimeUnit.SECONDS));
|
||||
workers.shutdown(); assertTrue(workers.awaitTermination(2, TimeUnit.SECONDS)); assertEquals(0, calls.get());
|
||||
}
|
||||
|
||||
@Test void interruptionCancelsSocketAndRestoresCallerInterruptFlag() throws Exception {
|
||||
var arrived = new CountDownLatch(1); var observed = new AtomicReference<BoundedHttpTransport.Reason>(); var flag = new AtomicReference<Boolean>();
|
||||
server.createContext("/", exchange -> {
|
||||
exchange.sendResponseHeaders(200, 0);
|
||||
try (var output = exchange.getResponseBody()) {
|
||||
output.write('x'); output.flush(); arrived.countDown();
|
||||
try { release.await(5, TimeUnit.SECONDS); } catch (InterruptedException error) { Thread.currentThread().interrupt(); }
|
||||
} catch (java.io.IOException expectedAfterCancellation) { }
|
||||
}); server.start();
|
||||
var caller = new Thread(() -> {
|
||||
try { get("/", 5000, 1024); }
|
||||
catch (BoundedHttpTransport.Failure failure) { observed.set(failure.reason()); flag.set(Thread.currentThread().isInterrupted()); }
|
||||
catch (Exception unexpected) { throw new AssertionError(unexpected); }
|
||||
}); caller.setDaemon(true); caller.start();
|
||||
try {
|
||||
assertTrue(arrived.await(3, TimeUnit.SECONDS)); caller.interrupt(); caller.join(2000);
|
||||
assertFalse(caller.isAlive()); assertEquals(BoundedHttpTransport.Reason.INTERRUPTED, observed.get()); assertEquals(true, flag.get());
|
||||
} finally { release.countDown(); caller.interrupt(); }
|
||||
}
|
||||
|
||||
@Test void refusedOrDroppedRequestsAreNotAutomaticallyRetried() {
|
||||
var calls = new AtomicInteger();
|
||||
server.createContext("/", exchange -> { calls.incrementAndGet(); exchange.close(); }); server.start();
|
||||
assertThrows(BoundedHttpTransport.Failure.class, () -> get("/", 3000, 1024)); assertEquals(1, calls.get());
|
||||
}
|
||||
|
||||
@Test void compressedBodiesAreNotDecompressedOrTreatedAsImages() {
|
||||
server.createContext("/", exchange -> {
|
||||
exchange.getResponseHeaders().set("Content-Encoding", "gzip"); exchange.sendResponseHeaders(200, 0);
|
||||
try (var output = exchange.getResponseBody()) { output.write(new byte[16]); }
|
||||
catch (java.io.IOException expectedAfterCancellation) { }
|
||||
}); server.start();
|
||||
assertEquals(BoundedHttpTransport.Reason.IO, assertThrows(BoundedHttpTransport.Failure.class, () -> get("/", 3000, 1024)).reason());
|
||||
}
|
||||
|
||||
@Test void busyPoolRejectsImmediatelyRatherThanQueueingUnlimitedDnsRequests() throws Exception {
|
||||
var occupied = new CountDownLatch(1);
|
||||
var oneWorker = new ThreadPoolExecutor(0, 1, 5, TimeUnit.SECONDS, new SynchronousQueue<>());
|
||||
try {
|
||||
oneWorker.submit(() -> {
|
||||
occupied.countDown();
|
||||
try { release.await(5, TimeUnit.SECONDS); } catch (InterruptedException error) { Thread.currentThread().interrupt(); }
|
||||
});
|
||||
assertTrue(occupied.await(2, TimeUnit.SECONDS));
|
||||
var rejected = new PinnedHttpsTransport(trustedTls, oneWorker);
|
||||
var failure = assertThrows(BoundedHttpTransport.Failure.class, () -> rejected.get(uri("/"), this::loopback, Duration.ofSeconds(3), 1024));
|
||||
assertEquals(BoundedHttpTransport.Reason.BUSY, failure.reason()); assertNull(failure.observedStatus());
|
||||
assertEquals(0, oneWorker.getQueue().size());
|
||||
} finally { release.countDown(); oneWorker.shutdownNow(); assertTrue(oneWorker.awaitTermination(2, TimeUnit.SECONDS)); }
|
||||
}
|
||||
|
||||
@Test void defaultSystemProxySelectorCannotBypassDnsBinding() throws Exception {
|
||||
var original = java.net.ProxySelector.getDefault();
|
||||
var selections = new AtomicInteger();
|
||||
server.createContext("/", exchange -> { exchange.sendResponseHeaders(200, 1); exchange.getResponseBody().write('x'); exchange.close(); }); server.start();
|
||||
try {
|
||||
java.net.ProxySelector.setDefault(new java.net.ProxySelector() {
|
||||
@Override public java.util.List<java.net.Proxy> select(URI target) {
|
||||
selections.incrementAndGet();
|
||||
return java.util.List.of(new java.net.Proxy(java.net.Proxy.Type.SOCKS, new InetSocketAddress("127.0.0.1", 1)));
|
||||
}
|
||||
@Override public void connectFailed(URI target, java.net.SocketAddress address, java.io.IOException failure) { }
|
||||
});
|
||||
assertEquals(200, get("/", 3000, 1024).statusCode()); assertEquals(0, selections.get());
|
||||
} finally { java.net.ProxySelector.setDefault(original); }
|
||||
}
|
||||
|
||||
@Test void independentAttemptsRevalidateDnsAndNeverReuseCookiesOrThePreviousConnection() throws Exception {
|
||||
var calls = new AtomicInteger(); var lookups = new AtomicInteger();
|
||||
server.createContext("/", exchange -> {
|
||||
calls.incrementAndGet(); assertNull(exchange.getRequestHeaders().getFirst("Cookie"));
|
||||
exchange.getResponseHeaders().set("Set-Cookie", "synthetic=value; Secure");
|
||||
exchange.sendResponseHeaders(200, 1); exchange.getResponseBody().write('x'); exchange.close();
|
||||
}); server.start();
|
||||
PinnedHttpsTransport.AddressResolver resolver = host -> {
|
||||
if (lookups.incrementAndGet() == 3) throw new PinnedHttpsTransport.AddressRejectedException();
|
||||
return loopback(host);
|
||||
};
|
||||
assertEquals(200, transport.get(uri("/"), resolver, Duration.ofSeconds(3), 1024).statusCode());
|
||||
assertEquals(200, transport.get(uri("/"), resolver, Duration.ofSeconds(3), 1024).statusCode());
|
||||
assertEquals(BoundedHttpTransport.Reason.INVALID_ADDRESS, assertThrows(BoundedHttpTransport.Failure.class,
|
||||
() -> transport.get(uri("/"), resolver, Duration.ofSeconds(3), 1024)).reason());
|
||||
assertEquals(3, lookups.get()); assertEquals(2, calls.get());
|
||||
}
|
||||
|
||||
@Test void errorBodyLimitRetainsStatusAndIsSmallerThanTheImageLimit() {
|
||||
server.createContext("/", exchange -> { exchange.sendResponseHeaders(401, 1_000_000); exchange.close(); }); server.start();
|
||||
var failure = assertThrows(BoundedHttpTransport.Failure.class, () -> get("/", 3000, 8 * 1024 * 1024));
|
||||
assertEquals(BoundedHttpTransport.Reason.BODY_TOO_LARGE, failure.reason()); assertEquals(401, failure.observedStatus());
|
||||
}
|
||||
|
||||
@Test void oversizedResponseHeadersAreNotBufferedWithoutLimits() {
|
||||
server.createContext("/", exchange -> {
|
||||
exchange.getResponseHeaders().set("X-Large", "x".repeat(16 * 1024));
|
||||
exchange.sendResponseHeaders(200, 1); exchange.getResponseBody().write('x'); exchange.close();
|
||||
}); server.start();
|
||||
assertEquals(BoundedHttpTransport.Reason.IO, assertThrows(BoundedHttpTransport.Failure.class, () -> get("/", 3000, 1024)).reason());
|
||||
}
|
||||
}
|
||||
+18
@@ -322,6 +322,24 @@ class AsyncProviderClientTest {
|
||||
assertEquals("INVALID_MEDIA_URL", failure.getCode());
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@CsvSource({"image,gpt-image-2", "video,sora-2", "image,gemini-3-pro-image-preview"})
|
||||
void localReferenceImageIsRejectedBeforeAnyGenerationPost(String type, String model) throws Exception {
|
||||
var calls = new java.util.concurrent.atomic.AtomicInteger();
|
||||
HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
|
||||
server.createContext("/", exchange -> { calls.incrementAndGet(); exchange.sendResponseHeaders(500, -1); exchange.close(); }); server.start();
|
||||
try {
|
||||
var jdbc = mock(JdbcTemplate.class); var cipher = new SecretCipher("test-encryption");
|
||||
when(jdbc.queryForMap(any(String.class), eq("relay"))).thenReturn(Map.of("code", "relay", "protocol", "openai-compatible",
|
||||
"base_url", "http://127.0.0.1:" + server.getAddress().getPort(), "credential_ciphertext", cipher.encrypt("test-key")));
|
||||
var client = new AsyncProviderClient(jdbc, cipher, new ObjectMapper(), mock(Environment.class));
|
||||
var failure = assertThrows(ProviderRequestException.class, () -> client.submit("relay", model, type,
|
||||
Map.of("prompt", "synthetic", "media_url", "https://127.0.0.1/private")));
|
||||
assertEquals(ProviderRequestException.Acceptance.NOT_SENT, failure.acceptance()); assertEquals("INVALID_MEDIA_URL", failure.getCode());
|
||||
assertEquals(0, calls.get());
|
||||
} finally { server.stop(0); }
|
||||
}
|
||||
|
||||
private AsyncProviderClient clientFor(String baseUrl) {
|
||||
JdbcTemplate jdbc = mock(JdbcTemplate.class);
|
||||
SecretCipher cipher = new SecretCipher("test-encryption");
|
||||
|
||||
Reference in new issue
Block a user