Add test for ClusterSettings impl, add javadoc

Author: JeremyDahlgren

server/src/main/java/org/elasticsearch/transport/AbstractLinkedProjectConfigService.java

@@ -14,6 +14,10 @@
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
 
+/**
+ * Abstract base class for {@link LinkedProjectConfigService} implementations.
+ * Provides common functionality for managing a list of registered listeners and notifying them of updates.
+ */
 public abstract class AbstractLinkedProjectConfigService implements LinkedProjectConfigService {
     private final List<LinkedProjectConfigListener> listeners = new CopyOnWriteArrayList<>();
 

server/src/main/java/org/elasticsearch/transport/ClusterSettingsLinkedProjectConfigService.java

@@ -18,6 +18,10 @@
 import java.util.Collection;
 import java.util.List;
 
+/**
+ * A {@link LinkedProjectConfigService} implementation that listens for {@link ClusterSettings} changes,
+ * creating {@link LinkedProjectConfig}s from the relevant settings and notifying registered listeners of updates.
+ */
 public class ClusterSettingsLinkedProjectConfigService extends AbstractLinkedProjectConfigService {
     private final Settings settings;
     private final ProjectResolver projectResolver;

server/src/main/java/org/elasticsearch/transport/LinkedProjectConfigService.java

@@ -14,11 +14,32 @@
 import java.util.Collection;
 import java.util.Collections;
 
+/**
+ * Service for registering {@link LinkedProjectConfigListener}s to be notified of changes to linked project configurations.
+ */
 public interface LinkedProjectConfigService {
 
+    /**
+     * Listener interface for receiving updates about linked project configurations.
+     * Implementations must not throw from any of the interface methods.
+     */
     interface LinkedProjectConfigListener {
+        /**
+         * Called when a linked project configuration has been added or updated.
+         *
+         * @param config The updated {@link LinkedProjectConfig}.
+         */
         void updateLinkedProject(LinkedProjectConfig config);
 
+        /**
+         * Called when the boolean skip_unavailable setting has changed for a linked project configuration.
+         * Note that skip_unavailable may not be supported in all contexts where linked projects are used.
+         *
+         * @param originProjectId The {@link ProjectId} of the owning project that has the linked project configuration.
+         * @param linkedProjectId The {@link ProjectId} of the linked project.
+         * @param linkedProjectAlias The alias used for the linked project.
+         * @param skipUnavailable The new value of the skip_unavailable setting.
+         */
         default void skipUnavailableChanged(
             ProjectId originProjectId,
             ProjectId linkedProjectId,
@@ -27,10 +48,24 @@ default void skipUnavailableChanged(
         ) {}
     }
 
+    /**
+     * Registers a {@link LinkedProjectConfigListener} to receive updates about linked project configurations.
+     *
+     * @param listener The listener to register.
+     */
     void register(LinkedProjectConfigListener listener);
 
+    /**
+     * Loads all existing linked project configurations for all origin projects.
+     *
+     * @return A collection of all existing {@link LinkedProjectConfig}s.
+     */
     Collection<LinkedProjectConfig> loadAllLinkedProjectConfigs();
 
+    /**
+     * A no-op stub implementation of {@link LinkedProjectConfigService} intended for use in test scenarios where linked project
+     * configuration updates are not needed.
+     */
     LinkedProjectConfigService NOOP = new LinkedProjectConfigService() {
         @Override
         public void register(LinkedProjectConfigListener listener) {}

server/src/test/java/org/elasticsearch/transport/ClusterSettingsLinkedProjectConfigServiceTests.java

@@ -0,0 +1,139 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+package org.elasticsearch.transport;
+
+import org.elasticsearch.cluster.metadata.ProjectId;
+import org.elasticsearch.cluster.project.DefaultProjectResolver;
+import org.elasticsearch.common.settings.ClusterSettings;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.test.ESTestCase;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.elasticsearch.transport.LinkedProjectConfigService.LinkedProjectConfigListener;
+import static org.elasticsearch.transport.LinkedProjectConfig.ProxyLinkedProjectConfigBuilder;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.sameInstance;
+
+public class ClusterSettingsLinkedProjectConfigServiceTests extends ESTestCase {
+
+    private record SkipUnavailableUpdate(
+        ProjectId originProjectId,
+        ProjectId linkedProjectId,
+        String linkedProjectAlias,
+        boolean skipUnavailable
+    ) {}
+
+    private static class StubLinkedProjectConfigListener implements LinkedProjectConfigListener {
+        LinkedProjectConfig updatedConfig;
+        SkipUnavailableUpdate skipUnavailableUpdate;
+
+        @Override
+        public void updateLinkedProject(LinkedProjectConfig config) {
+            updatedConfig = config;
+        }
+
+        @Override
+        public void skipUnavailableChanged(
+            ProjectId originProjectId,
+            ProjectId linkedProjectId,
+            String linkedProjectAlias,
+            boolean skipUnavailable
+        ) {
+            skipUnavailableUpdate = new SkipUnavailableUpdate(originProjectId, linkedProjectId, linkedProjectAlias, skipUnavailable);
+        }
+
+        void reset() {
+            updatedConfig = null;
+            skipUnavailableUpdate = null;
+        }
+    }
+
+    /**
+     * A simple test to exercise the callback registration and notification mechanism.
+     * Note that {@link RemoteClusterServiceTests} uses {@link ClusterSettingsLinkedProjectConfigService}
+     * and contains more thorough tests of all the settings being monitored.
+     */
+    public void testListenersReceiveUpdates() {
+        final var alias = randomAlphaOfLength(10);
+
+        final var initialProxyAddress = "localhost:9400";
+        final var initialSettings = Settings.builder()
+            .put("cluster.remote." + alias + ".mode", "proxy")
+            .put("cluster.remote." + alias + ".proxy_address", initialProxyAddress)
+            .build();
+        final var clusterSettings = ClusterSettings.createBuiltInClusterSettings(initialSettings);
+        final var service = new ClusterSettingsLinkedProjectConfigService(
+            initialSettings,
+            clusterSettings,
+            DefaultProjectResolver.INSTANCE
+        );
+        final var config = new ProxyLinkedProjectConfigBuilder(alias).proxyAddress(initialProxyAddress).build();
+
+        // Verify we can get the linked projects on startup.
+        assertThat(service.loadAllLinkedProjectConfigs(), equalTo(List.of(config)));
+
+        final int numListeners = randomIntBetween(1, 10);
+        final var listeners = new ArrayList<StubLinkedProjectConfigListener>(numListeners);
+        for (int i = 0; i < numListeners; ++i) {
+            listeners.add(new StubLinkedProjectConfigListener());
+            service.register(listeners.getLast());
+        }
+
+        // Expect no updates when applying the same settings.
+        clusterSettings.applySettings(initialSettings);
+        for (int i = 0; i < numListeners; ++i) {
+            assertThat(listeners.get(i).updatedConfig, sameInstance(null));
+            assertThat(listeners.get(i).skipUnavailableUpdate, sameInstance(null));
+            listeners.get(i).reset();
+        }
+
+        // Change the skip_unavailable, leave the other settings alone, we should get the skip_unavailable update only.
+        var expectedSkipUnavailableUpdate = new SkipUnavailableUpdate(
+            config.originProjectId(),
+            config.linkedProjectId(),
+            config.linkedProjectAlias(),
+            config.skipUnavailable() == false
+        );
+        clusterSettings.applySettings(
+            Settings.builder()
+                .put(initialSettings)
+                .put("cluster.remote." + alias + ".skip_unavailable", expectedSkipUnavailableUpdate.skipUnavailable)
+                .build()
+        );
+        for (int i = 0; i < numListeners; ++i) {
+            assertThat(listeners.get(i).updatedConfig, sameInstance(null));
+            assertThat(listeners.get(i).skipUnavailableUpdate, equalTo(expectedSkipUnavailableUpdate));
+            listeners.get(i).reset();
+        }
+
+        // Change the proxy address, and set skip_unavailable back to original value, we should get both updates.
+        expectedSkipUnavailableUpdate = new SkipUnavailableUpdate(
+            config.originProjectId(),
+            config.linkedProjectId(),
+            config.linkedProjectAlias(),
+            config.skipUnavailable()
+        );
+        final var newProxyAddress = "localhost:9401";
+        clusterSettings.applySettings(
+            Settings.builder()
+                .put(initialSettings)
+                .put("cluster.remote." + alias + ".proxy_address", newProxyAddress)
+                .put("cluster.remote." + alias + ".skip_unavailable", expectedSkipUnavailableUpdate.skipUnavailable)
+                .build()
+        );
+        for (int i = 0; i < numListeners; ++i) {
+            assertNotNull("expected non-null updatedConfig for listener " + i, listeners.get(i).updatedConfig);
+            assertThat(listeners.get(i).updatedConfig.proxyAddress(), equalTo(newProxyAddress));
+            assertThat(listeners.get(i).skipUnavailableUpdate, equalTo(expectedSkipUnavailableUpdate));
+        }
+    }
+}