Proxy Registry: refactoring, Redis Client: add support for Proxy Registry

extensions/proxy-registry/deployment/pom.xml

@@ -29,6 +29,12 @@
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-credentials-deployment</artifactId>
         </dependency>
+
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-junit5-internal</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>

extensions/proxy-registry/deployment/src/main/java/io/quarkus/proxy/deployment/ProxyRegistryBuildItem.java

@@ -0,0 +1,21 @@
+package io.quarkus.proxy.deployment;
+
+import java.util.function.Supplier;
+
+import io.quarkus.builder.item.SimpleBuildItem;
+import io.quarkus.proxy.ProxyConfigurationRegistry;
+
+/**
+ * A build item that indicates that the proxy registry has been initialized.
+ */
+public final class ProxyRegistryBuildItem extends SimpleBuildItem {
+    private final Supplier<ProxyConfigurationRegistry> registry;
+
+    public ProxyRegistryBuildItem(Supplier<ProxyConfigurationRegistry> registry) {
+        this.registry = registry;
+    }
+
+    public Supplier<ProxyConfigurationRegistry> registry() {
+        return registry;
+    }
+}

extensions/proxy-registry/deployment/src/main/java/io/quarkus/proxy/deployment/ProxyRegistryProcessor.java

@@ -0,0 +1,37 @@
+package io.quarkus.proxy.deployment;
+
+import java.util.function.Supplier;
+
+import jakarta.inject.Singleton;
+
+import io.quarkus.arc.deployment.SyntheticBeanBuildItem;
+import io.quarkus.deployment.annotations.BuildProducer;
+import io.quarkus.deployment.annotations.BuildStep;
+import io.quarkus.deployment.annotations.ExecutionTime;
+import io.quarkus.deployment.annotations.Record;
+import io.quarkus.proxy.ProxyConfigurationRegistry;
+import io.quarkus.proxy.runtime.ProxyConfigurationRecorder;
+import io.quarkus.proxy.runtime.ProxyConfigurationRegistryImpl;
+
+public class ProxyRegistryProcessor {
+    @BuildStep
+    @Record(ExecutionTime.RUNTIME_INIT)
+    void initializeProxyConfigurationRegistry(
+            ProxyConfigurationRecorder recorder,
+            BuildProducer<ProxyRegistryBuildItem> registry,
+            BuildProducer<SyntheticBeanBuildItem> syntheticBeans) {
+
+        Supplier<ProxyConfigurationRegistry> supplier = recorder.init();
+
+        registry.produce(new ProxyRegistryBuildItem(supplier));
+
+        syntheticBeans.produce(SyntheticBeanBuildItem.create(ProxyConfigurationRegistryImpl.class)
+                .addType(ProxyConfigurationRegistry.class)
+                .supplier(supplier)
+                .scope(Singleton.class)
+                .unremovable()
+                .setRuntimeInit()
+                .done());
+
+    }
+}

extensions/proxy-registry/deployment/src/test/java/io/quarkus/proxy/test/DefaultProxyMissingTest.java

@@ -0,0 +1,28 @@
+package io.quarkus.proxy.test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.Optional;
+
+import jakarta.inject.Inject;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.proxy.ProxyConfiguration;
+import io.quarkus.proxy.ProxyConfigurationRegistry;
+import io.quarkus.test.QuarkusUnitTest;
+
+public class DefaultProxyMissingTest {
+    @RegisterExtension
+    static final QuarkusUnitTest config = new QuarkusUnitTest();
+
+    @Inject
+    ProxyConfigurationRegistry registry;
+
+    @Test
+    public void test() {
+        Optional<ProxyConfiguration> proxy = registry.get(Optional.empty());
+        assertTrue(proxy.isEmpty());
+    }
+}

extensions/proxy-registry/deployment/src/test/java/io/quarkus/proxy/test/DefaultProxyPresentTest.java

@@ -0,0 +1,41 @@
+package io.quarkus.proxy.test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.Optional;
+
+import jakarta.inject.Inject;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.proxy.ProxyConfiguration;
+import io.quarkus.proxy.ProxyConfigurationRegistry;
+import io.quarkus.proxy.ProxyType;
+import io.quarkus.test.QuarkusUnitTest;
+
+public class DefaultProxyPresentTest {
+    @RegisterExtension
+    static final QuarkusUnitTest config = new QuarkusUnitTest()
+            .withConfigurationResource("default-proxy-present.properties");
+
+    @Inject
+    ProxyConfigurationRegistry registry;
+
+    @Test
+    public void test() {
+        Optional<ProxyConfiguration> proxy = registry.get(Optional.empty());
+        assertTrue(proxy.isPresent());
+        ProxyConfiguration cfg = proxy.get();
+        assertEquals("localhost", cfg.host());
+        assertEquals(3128, cfg.port());
+        assertEquals(Optional.of("user"), cfg.username());
+        assertEquals(Optional.of("pwd"), cfg.password());
+        assertEquals(Optional.of(List.of("localhost", "example.com")), cfg.nonProxyHosts());
+        assertEquals(Optional.of(Duration.ofSeconds(1)), cfg.proxyConnectTimeout());
+        assertEquals(ProxyType.HTTP, cfg.type());
+    }
+}

extensions/proxy-registry/deployment/src/test/java/io/quarkus/proxy/test/NamedProxyTest.java

@@ -0,0 +1,61 @@
+package io.quarkus.proxy.test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.Optional;
+
+import jakarta.inject.Inject;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.proxy.ProxyConfiguration;
+import io.quarkus.proxy.ProxyConfigurationRegistry;
+import io.quarkus.proxy.ProxyType;
+import io.quarkus.test.QuarkusUnitTest;
+
+public class NamedProxyTest {
+    @RegisterExtension
+    static final QuarkusUnitTest config = new QuarkusUnitTest()
+            .withConfigurationResource("named-proxy.properties");
+
+    @Inject
+    ProxyConfigurationRegistry registry;
+
+    @Test
+    public void testPresent() {
+        Optional<ProxyConfiguration> proxy = registry.get(Optional.of("my-proxy"));
+        assertTrue(proxy.isPresent());
+        ProxyConfiguration cfg = proxy.get();
+        assertEquals("localhost", cfg.host());
+        assertEquals(3128, cfg.port());
+        assertEquals(Optional.of("user"), cfg.username());
+        assertEquals(Optional.of("pwd"), cfg.password());
+        assertEquals(Optional.of(List.of("localhost", "example.com")), cfg.nonProxyHosts());
+        assertEquals(Optional.of(Duration.ofSeconds(1)), cfg.proxyConnectTimeout());
+        assertEquals(ProxyType.HTTP, cfg.type());
+    }
+
+    @Test
+    public void testMissing() {
+        assertThrows(IllegalStateException.class, () -> registry.get(Optional.of("missing")));
+    }
+
+    @Test
+    public void testNone() {
+        Optional<ProxyConfiguration> proxy = registry.get(Optional.of("none"));
+        assertTrue(proxy.isPresent());
+        ProxyConfiguration cfg = proxy.get();
+        assertEquals("none", cfg.host());
+        assertEquals(0, cfg.port());
+        assertEquals(Optional.empty(), cfg.username());
+        assertEquals(Optional.empty(), cfg.password());
+        assertEquals(Optional.empty(), cfg.nonProxyHosts());
+        assertEquals(Optional.empty(), cfg.proxyConnectTimeout());
+        assertEquals(ProxyType.HTTP, cfg.type());
+    }
+}

extensions/proxy-registry/deployment/src/test/resources/default-proxy-present.properties

@@ -0,0 +1,6 @@
+quarkus.proxy.host=localhost
+quarkus.proxy.port=3128
+quarkus.proxy.username=user
+quarkus.proxy.password=pwd
+quarkus.proxy.non-proxy-hosts=localhost,example.com
+quarkus.proxy.proxy-connect-timeout=1s

extensions/proxy-registry/deployment/src/test/resources/named-proxy.properties

@@ -0,0 +1,6 @@
+quarkus.proxy.my-proxy.host=localhost
+quarkus.proxy.my-proxy.port=3128
+quarkus.proxy.my-proxy.username=user
+quarkus.proxy.my-proxy.password=pwd
+quarkus.proxy.my-proxy.non-proxy-hosts=localhost,example.com
+quarkus.proxy.my-proxy.proxy-connect-timeout=1s

extensions/proxy-registry/runtime/src/main/java/io/quarkus/proxy/ProxyConfiguration.java

@@ -0,0 +1,54 @@
+package io.quarkus.proxy;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.Optional;
+
+public interface ProxyConfiguration {
+    /**
+     * Proxy host
+     */
+    String host();
+
+    /**
+     * Proxy port
+     */
+    int port();
+
+    /**
+     * Proxy username
+     */
+    Optional<String> username();
+
+    /**
+     * Proxy password
+     */
+    Optional<String> password();
+
+    /**
+     * Hostnames or IP addresses to exclude from proxying.
+     */
+    Optional<List<String>> nonProxyHosts();
+
+    /**
+     * Proxy connection timeout.
+     */
+    Optional<Duration> proxyConnectTimeout();
+
+    /**
+     * Proxy type.
+     */
+    ProxyType type();
+
+    /**
+     * @return this {@link ProxyConfiguration} if {@link #type()} returns {@link ProxyType#HTTP};
+     *         otherwise throws {@link IllegalStateException}
+     * @throws IllegalStateException if {@link #type()} does not return {@link ProxyType#HTTP}
+     */
+    default ProxyConfiguration assertHttpType() {
+        if (type() != ProxyType.HTTP) {
+            throw new IllegalStateException("Proxy type HTTP is required");
+        }
+        return this;
+    }
+}

extensions/proxy-registry/runtime/src/main/java/io/quarkus/proxy/ProxyConfigurationRegistry.java

@@ -0,0 +1,26 @@
+package io.quarkus.proxy;
+
+import java.util.Optional;
+
+public interface ProxyConfigurationRegistry {
+    /**
+     * Signals that no proxy should be used.
+     * No proxy configuration may use this name.
+     */
+    String NONE = "none";
+
+    /**
+     * If the given {@code name} is not empty, returns the named proxy configuration
+     * if it exists and throws an exception if it doesn't exist. If the given {@code name}
+     * is the special value {@link #NONE none}, returns a special result where the host and
+     * port are {@code none:0}, type is {@code HTTP} and other methods return an empty result.
+     * <p>
+     * If the given {@code name} is empty, returns the default proxy configuration
+     * if it exists and returns an {@linkplain Optional#empty() empty} result if it doesn't exist.
+     *
+     * @param name the name
+     * @return the configuration, may be empty
+     * @throws IllegalStateException if the named configuration does not exist
+     */
+    Optional<ProxyConfiguration> get(Optional<String> name);
+}

extensions/proxy-registry/runtime/src/main/java/io/quarkus/proxy/ProxyType.java

@@ -0,0 +1,7 @@
+package io.quarkus.proxy;
+
+public enum ProxyType {
+    HTTP,
+    SOCKS4,
+    SOCKS5,
+}