minimal impl

Author: jrhee17

core/src/main/java/com/linecorp/armeria/server/ConnectionLevelSetters.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2025 LINE Corporation
+ *
+ * LINE Corporation licenses this file to you 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:
+ *
+ *   https://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.
+ */
+
+package com.linecorp.armeria.server;
+
+import com.linecorp.armeria.common.annotation.Nullable;
+import com.linecorp.armeria.common.annotation.UnstableApi;
+
+@UnstableApi
+interface ConnectionLevelSetters {
+
+    @Nullable
+    ConnectionAcceptor connectionAcceptor();
+
+    ConnectionLevelSetters connectionAcceptor(ConnectionAcceptor connectionAcceptor);
+
+    @Nullable
+    ServerTlsProvider tlsProvider();
+
+    ConnectionLevelSetters tlsProvider(ServerTlsProvider serverTlsProvider);
+}

core/src/main/java/com/linecorp/armeria/server/ServerBuilder.java

@@ -172,7 +172,8 @@
  *
  * @see VirtualHostBuilder
  */
-public final class ServerBuilder implements TlsSetters, ServiceConfigsBuilder<ServerBuilder> {
+public final class ServerBuilder implements ConnectionLevelSetters, TlsSetters,
+        ServiceConfigsBuilder<ServerBuilder> {
     private static final Logger logger = LoggerFactory.getLogger(ServerBuilder.class);
 
     // Defaults to no graceful shutdown.
@@ -531,12 +532,22 @@ public ServerBuilder childChannelPipelineCustomizer(
      * Sets the {@link ConnectionAcceptor} that is called once per connection, before TLS
      * negotiation, to decide whether to accept the connection.
      */
+    @Override
     @UnstableApi
     public ServerBuilder connectionAcceptor(ConnectionAcceptor connectionAcceptor) {
         this.connectionAcceptor = requireNonNull(connectionAcceptor, "connectionAcceptor");
         return this;
     }
 
+    /**
+     * Returns the {@link ConnectionAcceptor} configured so far.
+     */
+    @Override
+    @UnstableApi
+    public ConnectionAcceptor connectionAcceptor() {
+        return connectionAcceptor;
+    }
+
     /**
      * Adds a {@link ServerPlugin} that will be installed during {@link Server} construction
      * and during {@link Server#reconfigure(ServerConfigurator)}.
@@ -1243,6 +1254,16 @@ public ServerBuilder tls(KeyManagerFactory keyManagerFactory) {
         return this;
     }
 
+    /**
+     * Returns the {@link ServerTlsProvider} configured so far, or {@code null} if not set.
+     */
+    @Override
+    @UnstableApi
+    @Nullable
+    public ServerTlsProvider tlsProvider() {
+        return serverTlsProviderBuilder.serverTlsProvider;
+    }
+
     /**
      * Sets the specified {@link TlsProvider} which will be used for building an {@link SslContext} of
      * a hostname.
@@ -1322,6 +1343,7 @@ public ServerBuilder tlsProvider(TlsProvider tlsProvider, ServerTlsConfig tlsCon
      * the {@code tlsProvider} takes priority. The static TLS settings are used as a fallback
      * when the provider returns {@code null}.
      */
+    @Override
     @UnstableApi
     public ServerBuilder tlsProvider(ServerTlsProvider serverTlsProvider) {
         requireNonNull(serverTlsProvider, "serverTlsProvider");

it/xds-client/src/test/java/com/linecorp/armeria/xds/it/XdsCertificateExtension.java

@@ -52,14 +52,14 @@
  *         new XdsCertificateExtension(new SelfSignedCertificateExtension("localhost"));
  * }</pre>
  */
-final class XdsCertificateExtension extends AbstractAllOrEachExtension {
+public final class XdsCertificateExtension extends AbstractAllOrEachExtension {
 
     private final SelfSignedCertificateExtension delegate;
     private Path tempDir;
     private File certificateFile;
     private File privateKeyFile;
 
-    XdsCertificateExtension(SelfSignedCertificateExtension delegate) {
+    public XdsCertificateExtension(SelfSignedCertificateExtension delegate) {
         this.delegate = delegate;
     }
 
@@ -79,23 +79,23 @@ protected void after(ExtensionContext context) throws Exception {
         }
     }
 
-    File certificateFile() {
+    public File certificateFile() {
         return certificateFile;
     }
 
-    File privateKeyFile() {
+    public File privateKeyFile() {
         return privateKeyFile;
     }
 
-    X509Certificate certificate() {
+    public X509Certificate certificate() {
         return delegate.certificate();
     }
 
-    PrivateKey privateKey() {
+    public PrivateKey privateKey() {
         return delegate.privateKey();
     }
 
-    TlsKeyPair tlsKeyPair() {
+    public TlsKeyPair tlsKeyPair() {
         return delegate.tlsKeyPair();
     }
 

it/xds-client/src/test/java/com/linecorp/armeria/xds/it/XdsControlPlaneExtension.java

@@ -0,0 +1,229 @@
+/*
+ * Copyright 2026 LY Corporation
+ *
+ * LY Corporation licenses this file to you 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:
+ *
+ *   https://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.
+ */
+package com.linecorp.armeria.xds.it;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.awaitility.Awaitility.await;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Consumer;
+
+import org.junit.jupiter.api.extension.ExtensionContext;
+
+import com.google.common.collect.ImmutableList;
+
+import com.linecorp.armeria.common.SessionProtocol;
+import com.linecorp.armeria.server.Server;
+import com.linecorp.armeria.server.grpc.GrpcService;
+import com.linecorp.armeria.testing.junit5.common.AbstractAllOrEachExtension;
+import com.linecorp.armeria.xds.ListenerRoot;
+import com.linecorp.armeria.xds.ListenerSnapshot;
+import com.linecorp.armeria.xds.XdsBootstrap;
+import com.linecorp.armeria.xds.XdsBootstrapBuilder;
+
+import io.envoyproxy.controlplane.cache.v3.SimpleCache;
+import io.envoyproxy.controlplane.cache.v3.Snapshot;
+import io.envoyproxy.controlplane.server.V3DiscoveryServer;
+import io.envoyproxy.envoy.config.bootstrap.v3.Bootstrap;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment;
+import io.envoyproxy.envoy.config.listener.v3.Listener;
+import io.envoyproxy.envoy.config.route.v3.RouteConfiguration;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.Secret;
+
+/**
+ * A JUnit 5 extension that manages an xDS control plane server, an internal
+ * {@link XdsBootstrap}, and a mutable resource map. All standard discovery services
+ * (ADS, LDS, RDS, CDS, EDS, SDS) are registered on a single ephemeral HTTP port.
+ *
+ * <p>Usage:
+ * <pre>{@code
+ * @RegisterExtension
+ * @Order(0)
+ * static final XdsControlPlaneExtension controlPlane = new XdsControlPlaneExtension();
+ *
+ * @RegisterExtension
+ * @Order(1)
+ * static final ServerExtension server = new ServerExtension() {
+ *     protected void configure(ServerBuilder sb) {
+ *         controlPlane.set(myListener);
+ *         sb.plugin(XdsServerPlugin.of(controlPlane.bootstrap(), "my-listener"));
+ *         sb.service("/hello", (ctx, req) -> HttpResponse.of("hello"));
+ *     }
+ * };
+ *
+ * @Test
+ * void test() {
+ *     String ver = controlPlane.set(updatedListener);
+ *     controlPlane.awaitListener("my-listener", ver);
+ *     // make assertions...
+ * }
+ * }</pre>
+ */
+public final class XdsControlPlaneExtension extends AbstractAllOrEachExtension {
+
+    private static final String GROUP = "key";
+
+    private final SimpleCache<String> cache = new SimpleCache<>(node -> GROUP);
+    private final AtomicLong version = new AtomicLong();
+    private final Consumer<XdsBootstrapBuilder> bootstrapCustomizer;
+
+    private List<Listener> listeners = ImmutableList.of();
+    private List<Cluster> clusters = ImmutableList.of();
+    private List<ClusterLoadAssignment> endpoints = ImmutableList.of();
+    private List<RouteConfiguration> routes = ImmutableList.of();
+    private List<Secret> secrets = ImmutableList.of();
+
+    private Server server;
+    private XdsBootstrap xdsBootstrap;
+
+    public XdsControlPlaneExtension() {
+        this(builder -> {});
+    }
+
+    public XdsControlPlaneExtension(Consumer<XdsBootstrapBuilder> bootstrapCustomizer) {
+        this.bootstrapCustomizer = bootstrapCustomizer;
+    }
+
+    @Override
+    protected void before(ExtensionContext context) throws Exception {
+        final V3DiscoveryServer ds = new V3DiscoveryServer(cache);
+        server = Server.builder()
+                       .service(GrpcService.builder()
+                                           .addService(ds.getAggregatedDiscoveryServiceImpl())
+                                           .addService(ds.getListenerDiscoveryServiceImpl())
+                                           .addService(ds.getRouteDiscoveryServiceImpl())
+                                           .addService(ds.getClusterDiscoveryServiceImpl())
+                                           .addService(ds.getEndpointDiscoveryServiceImpl())
+                                           .addService(ds.getSecretDiscoveryServiceImpl())
+                                           .build())
+                       .http(0)
+                       .build();
+        server.start().join();
+
+        final int port = server.activePort(SessionProtocol.HTTP).localAddress().getPort();
+        //language=YAML
+        final String yaml =
+                """
+                dynamic_resources:
+                  lds_config:
+                    api_config_source:
+                      api_type: GRPC
+                      grpc_services:
+                        - envoy_grpc:
+                            cluster_name: xds-cluster
+                  cds_config:
+                    api_config_source:
+                      api_type: GRPC
+                      grpc_services:
+                        - envoy_grpc:
+                            cluster_name: xds-cluster
+                static_resources:
+                  clusters:
+                    - name: xds-cluster
+                      type: STATIC
+                      load_assignment:
+                        cluster_name: xds-cluster
+                        endpoints:
+                          - lb_endpoints:
+                              - endpoint:
+                                  address:
+                                    socket_address:
+                                      address: 127.0.0.1
+                                      port_value: %d
+                """.formatted(port);
+        final XdsBootstrapBuilder builder =
+                XdsBootstrap.builder(XdsResourceReader.fromYaml(yaml, Bootstrap.class));
+        bootstrapCustomizer.accept(builder);
+        xdsBootstrap = builder.build();
+    }
+
+    @Override
+    protected void after(ExtensionContext context) throws Exception {
+        if (xdsBootstrap != null) {
+            xdsBootstrap.close();
+        }
+        if (server != null) {
+            server.stop().join();
+        }
+    }
+
+    public XdsBootstrap bootstrap() {
+        return xdsBootstrap;
+    }
+
+    public SimpleCache<String> cache() {
+        return cache;
+    }
+
+    public int httpPort() {
+        return server.activePort(SessionProtocol.HTTP).localAddress().getPort();
+    }
+
+    public String set(Listener... listeners) {
+        this.listeners = ImmutableList.copyOf(listeners);
+        return pushSnapshot();
+    }
+
+    public String set(Cluster... clusters) {
+        this.clusters = ImmutableList.copyOf(clusters);
+        return pushSnapshot();
+    }
+
+    public String set(ClusterLoadAssignment... endpoints) {
+        this.endpoints = ImmutableList.copyOf(endpoints);
+        return pushSnapshot();
+    }
+
+    public String set(RouteConfiguration... routes) {
+        this.routes = ImmutableList.copyOf(routes);
+        return pushSnapshot();
+    }
+
+    public String set(Secret... secrets) {
+        this.secrets = ImmutableList.copyOf(secrets);
+        return pushSnapshot();
+    }
+
+    /**
+     * Waits until the internal {@link XdsBootstrap} has received the specified version
+     * for the given listener name.
+     */
+    public void awaitListener(String listenerName, String version) {
+        try (ListenerRoot root = xdsBootstrap.listenerRoot(listenerName)) {
+            final AtomicReference<ListenerSnapshot> ref = new AtomicReference<>();
+            root.addSnapshotWatcher((snapshot, error) -> {
+                if (snapshot != null) {
+                    ref.set(snapshot);
+                }
+            });
+            await().untilAsserted(() -> {
+                final ListenerSnapshot snapshot = ref.get();
+                assertThat(snapshot).isNotNull();
+                assertThat(snapshot.xdsResource().version()).isEqualTo(version);
+            });
+        }
+    }
+
+    private String pushSnapshot() {
+        final String ver = String.valueOf(version.incrementAndGet());
+        cache.setSnapshot(GROUP, Snapshot.create(clusters, endpoints, listeners,
+                                                 routes, secrets, ver));
+        return ver;
+    }
+}