You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kafka.apache.org by mi...@apache.org on 2026/08/19 13:26:14 UTC

(kafka) branch trunk updated: MINOR: Refactor REST extension registration (#23150)

This is an automated email from the ASF dual-hosted git repository.

mimaison pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/kafka.git


The following commit(s) were added to refs/heads/trunk by this push:
     new 9521d77da39 MINOR: Refactor REST extension registration (#23150)
9521d77da39 is described below

commit 9521d77da39bc61e0d7b62356cf7d755b69e03e8
Author: Mickael Maison <mi...@users.noreply.github.com>
AuthorDate: Wed Aug 19 15:26:07 2026 +0200

    MINOR: Refactor REST extension registration (#23150)
    
    Refactor the Connect REST extension registration logic
    
    Reviewers: Manikumar Reddy <ma...@gmail.com>
---
 .../connect/runtime/rest/ConnectRestServer.java    | 16 ++--
 .../kafka/connect/runtime/rest/RestServer.java     | 34 ++++++--
 .../runtime/rest/ConnectRestServerTest.java        | 90 ++++++++++++++++++++++
 3 files changed, 126 insertions(+), 14 deletions(-)

diff --git a/connect/runtime/src/main/java/org/apache/kafka/connect/runtime/rest/ConnectRestServer.java b/connect/runtime/src/main/java/org/apache/kafka/connect/runtime/rest/ConnectRestServer.java
index db660f1651f..c936652c918 100644
--- a/connect/runtime/src/main/java/org/apache/kafka/connect/runtime/rest/ConnectRestServer.java
+++ b/connect/runtime/src/main/java/org/apache/kafka/connect/runtime/rest/ConnectRestServer.java
@@ -62,10 +62,19 @@ public class ConnectRestServer extends RestServer {
 
     @Override
     protected void configureRegularResources(ResourceConfig resourceConfig) {
-        registerRestExtensions(herder, resourceConfig);
         resourceConfig.register(new Binder());
     }
 
+    @Override
+    protected void configureAdminResources(ResourceConfig resourceConfig) {
+        resourceConfig.register(new Binder());
+    }
+
+    @Override
+    protected void configureExtensions(ResourceConfig resourceConfig, ResourceConfig adminResourceConfig) {
+        registerRestExtensions(herder, resourceConfig, adminResourceConfig);
+    }
+
     private class Binder extends AbstractBinder {
         @Override
         protected void configure() {
@@ -75,9 +84,4 @@ public class ConnectRestServer extends RestServer {
         }
     }
 
-    @Override
-    protected void configureAdminResources(ResourceConfig resourceConfig) {
-        resourceConfig.register(new Binder());
-    }
-
 }
diff --git a/connect/runtime/src/main/java/org/apache/kafka/connect/runtime/rest/RestServer.java b/connect/runtime/src/main/java/org/apache/kafka/connect/runtime/rest/RestServer.java
index 5bbc3312aa7..065aacaacc7 100644
--- a/connect/runtime/src/main/java/org/apache/kafka/connect/runtime/rest/RestServer.java
+++ b/connect/runtime/src/main/java/org/apache/kafka/connect/runtime/rest/RestServer.java
@@ -21,6 +21,7 @@ import org.apache.kafka.common.internals.Plugin;
 import org.apache.kafka.common.utils.Utils;
 import org.apache.kafka.connect.errors.ConnectException;
 import org.apache.kafka.connect.health.ConnectClusterDetails;
+import org.apache.kafka.connect.health.ConnectClusterState;
 import org.apache.kafka.connect.rest.ConnectRestExtension;
 import org.apache.kafka.connect.rest.ConnectRestExtensionContext;
 import org.apache.kafka.connect.runtime.Herder;
@@ -252,6 +253,8 @@ public abstract class RestServer {
             configureAdminResources(adminResourceConfig);
         }
 
+        configureExtensions(resourceConfig, adminResourceConfig);
+
         ServletContainer servletContainer = new ServletContainer(resourceConfig);
         ServletHolder servletHolder = new ServletHolder(servletContainer);
         List<Handler> contextHandlers = new ArrayList<>();
@@ -332,7 +335,6 @@ public abstract class RestServer {
     /**
      * Pluggable hook to customize the regular (i.e., non-admin) resources on this server
      * after they have been instantiated and registered with the given {@link ResourceConfig}.
-     * This may be used to, for example, add REST extensions via {@link #registerRestExtensions(Herder, ResourceConfig)}.
      * <p>
      * <em>N.B.: Classes do <b>not</b> need to register the resources provided in {@link #regularResources()} with
      * the {@link ResourceConfig} parameter in this method; they are automatically registered by the parent class.</em>
@@ -344,8 +346,7 @@ public abstract class RestServer {
 
     /**
      * Pluggable hook to customize the admin resources on this server after they have been instantiated and registered
-     * with the given {@link ResourceConfig}. This may be used to, for example, add REST extensions via
-     * {@link #registerRestExtensions(Herder, ResourceConfig)}.
+     * with the given {@link ResourceConfig}.
      * <p>
      * <em>N.B.: Classes do <b>not</b> need to register the resources provided in {@link #adminResources()} with
      * the {@link ResourceConfig} parameter in this method; they are automatically registered by the parent class.</em>
@@ -355,6 +356,15 @@ public abstract class RestServer {
         // No-op by default
     }
 
+    /**
+     * Pluggable hook to register REST extensions.
+     * @param resourceConfig the regular listener's {@link ResourceConfig}; never null
+     * @param adminResourceConfig the admin listener's {@link ResourceConfig}; never null
+     */
+    protected void configureExtensions(ResourceConfig resourceConfig, ResourceConfig adminResourceConfig) {
+        // No-op by default
+    }
+
     public URI serverUrl() {
         return jettyServer.getURI();
     }
@@ -503,7 +513,7 @@ public abstract class RestServer {
         return null;
     }
 
-    protected final void registerRestExtensions(Herder herder, ResourceConfig resourceConfig) {
+    protected final void registerRestExtensions(Herder herder, ResourceConfig resourceConfig, ResourceConfig adminResourceConfig) {
         connectRestExtensionPlugins = Plugin.wrapInstances(
                 herder.plugins().newPlugins(
                     config.restExtensions(),
@@ -525,15 +535,23 @@ public abstract class RestServer {
             herder.kafkaClusterId()
         );
 
-        ConnectRestExtensionContext connectRestExtensionContext =
+        ConnectClusterState connectClusterState = new ConnectClusterStateImpl(herderRequestTimeoutMs, connectClusterDetails, herder);
+
+        registerExtensionsWithConfig(resourceConfig, connectClusterState);
+        if (adminResourceConfig != resourceConfig) {
+            registerExtensionsWithConfig(adminResourceConfig, connectClusterState);
+        }
+    }
+
+    private void registerExtensionsWithConfig(ResourceConfig resourceConfig, ConnectClusterState connectClusterState) {
+        ConnectRestExtensionContext context =
             new ConnectRestExtensionContextImpl(
                 new ConnectRestConfigurable(resourceConfig),
-                new ConnectClusterStateImpl(herderRequestTimeoutMs, connectClusterDetails, herder)
+                connectClusterState
             );
         for (Plugin<ConnectRestExtension> connectRestExtensionPlugin : connectRestExtensionPlugins) {
-            connectRestExtensionPlugin.get().register(connectRestExtensionContext);
+            connectRestExtensionPlugin.get().register(context);
         }
-
     }
 
     /**
diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/ConnectRestServerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/ConnectRestServerTest.java
index a4368955504..cd8d3e27650 100644
--- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/ConnectRestServerTest.java
+++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/ConnectRestServerTest.java
@@ -66,12 +66,14 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
+import jakarta.ws.rs.container.ContainerResponseFilter;
 import jakarta.ws.rs.core.MediaType;
 
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 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.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
@@ -327,6 +329,80 @@ public class ConnectRestServerTest {
         assertEquals(404, response.getStatusLine().getStatusCode());
     }
 
+    @Test
+    public void testRestExtensionsRegisteredWithAdminListener() throws IOException {
+        Map<String, String> configMap = new HashMap<>(baseServerProps());
+        configMap.put(RestServerConfig.ADMIN_LISTENERS_CONFIG, "http://localhost:0");
+        configMap.put(RestServerConfig.REST_EXTENSION_CLASSES_CONFIG, HeaderConnectRestExtension.class.getName());
+
+        HeaderConnectRestExtension extension = new HeaderConnectRestExtension();
+        doReturn(KAFKA_CLUSTER_ID).when(herder).kafkaClusterId();
+        doReturn(plugins).when(herder).plugins();
+        doReturn(List.of(extension)).when(plugins).newPlugins(any(), any(), eq(ConnectRestExtension.class));
+        doReturn(List.of()).when(herder).connectors();
+
+        server = new ConnectRestServer(null, restClient, configMap);
+        server.initializeServer();
+        server.initializeResources(herder);
+
+        assertNotEquals(server.advertisedUrl(), server.adminUrl());
+        assertEquals(2, extension.registrations);
+
+        HttpResponse regularResponse = executeRequest(server.advertisedUrl(), new HttpGet("/connectors"));
+        assertEquals(200, regularResponse.getStatusLine().getStatusCode());
+        assertNotNull(regularResponse.getFirstHeader(extension.name));
+
+        HttpResponse adminResponse = executeRequest(server.adminUrl(), new HttpGet("/admin/loggers"));
+        assertEquals(200, adminResponse.getStatusLine().getStatusCode());
+        assertNotNull(adminResponse.getFirstHeader(extension.name));
+    }
+
+    @Test
+    public void testRestExtensionsWithoutAdminListener() throws IOException {
+        Map<String, String> configMap = new HashMap<>(baseServerProps());
+        configMap.put(RestServerConfig.REST_EXTENSION_CLASSES_CONFIG, HeaderConnectRestExtension.class.getName());
+
+        HeaderConnectRestExtension extension = new HeaderConnectRestExtension();
+        doReturn(KAFKA_CLUSTER_ID).when(herder).kafkaClusterId();
+        doReturn(plugins).when(herder).plugins();
+        doReturn(List.of(extension)).when(plugins).newPlugins(any(), any(), eq(ConnectRestExtension.class));
+        doReturn(List.of()).when(herder).connectors();
+
+        server = new ConnectRestServer(null, restClient, configMap);
+        server.initializeServer();
+        server.initializeResources(herder);
+
+        assertEquals(1, extension.registrations);
+
+        HttpResponse response = executeRequest(server.advertisedUrl(), new HttpGet("/connectors"));
+        assertEquals(200, response.getStatusLine().getStatusCode());
+        assertNotNull(response.getFirstHeader(extension.name));
+    }
+
+    @Test
+    public void testRestExtensionsWithDisabledAdminListener() throws IOException {
+        Map<String, String> configMap = new HashMap<>(baseServerProps());
+        configMap.put(RestServerConfig.ADMIN_LISTENERS_CONFIG, "");
+        configMap.put(RestServerConfig.REST_EXTENSION_CLASSES_CONFIG, HeaderConnectRestExtension.class.getName());
+
+        HeaderConnectRestExtension extension = new HeaderConnectRestExtension();
+        doReturn(KAFKA_CLUSTER_ID).when(herder).kafkaClusterId();
+        doReturn(plugins).when(herder).plugins();
+        doReturn(List.of(extension)).when(plugins).newPlugins(any(), any(), eq(ConnectRestExtension.class));
+        doReturn(List.of()).when(herder).connectors();
+
+        server = new ConnectRestServer(null, restClient, configMap);
+        server.initializeServer();
+        server.initializeResources(herder);
+
+        assertEquals(1, extension.registrations);
+
+        // Extensions should still work on the regular listener
+        HttpResponse response = executeRequest(server.advertisedUrl(), new HttpGet("/connectors"));
+        assertEquals(200, response.getStatusLine().getStatusCode());
+        assertNotNull(response.getFirstHeader(extension.name));
+    }
+
     @Test
     public void testDisableAdminEndpoint() throws IOException {
         Map<String, String> configMap = new HashMap<>(baseServerProps());
@@ -389,6 +465,20 @@ public class ConnectRestServerTest {
         checkCustomizedHttpResponseHeaders(headerConfig, expectedHeaders);
     }
 
+    static final class HeaderConnectRestExtension extends PluginsTest.TestConnectRestExtension {
+        String name = "X-Header";
+        int registrations = 0;
+
+        @Override
+        public void register(ConnectRestExtensionContext restPluginContext) {
+            registrations++;
+            restPluginContext.configurable().register(
+                (ContainerResponseFilter) (req, resp) ->
+                    resp.getHeaders().add(name, "true")
+            );
+        }
+    }
+
     static final class MonitorableConnectRestExtension extends PluginsTest.TestConnectRestExtension implements Monitorable {
 
         private boolean called = false;