[Feature/extensions] Add getSettings support for AD

CHANGELOG.md

@@ -98,6 +98,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
  - Pass full RestResponse to user from Extension ([#4356](https:/opensearch-project/OpenSearch/pull/4356))
  - Handle named wildcards (REST path parameters) ([#4415](https:/opensearch-project/OpenSearch/pull/4415))
  - Adding ActionListener onFailure to ExtensionsOrchestrator ([#61](https:/opensearch-project/opensearch-sdk/issues/61))
+ - Add getSettings support for AD([#4519](https:/opensearch-project/OpenSearch/pull/4519))
 
 ## [2.x]
 ### Added

server/src/main/java/org/opensearch/common/settings/WriteableSetting.java

@@ -0,0 +1,273 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.settings;
+
+import org.opensearch.Version;
+import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.StreamOutput;
+import org.opensearch.common.io.stream.Writeable;
+import org.opensearch.common.settings.Setting.Property;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.common.unit.TimeValue;
+import java.io.IOException;
+import java.util.EnumSet;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Wrapper for {@link Setting} with {@link #writeTo(StreamOutput)} implementation dependent on the setting type.
+ *
+ * @opensearch.internal
+ */
+public class WriteableSetting implements Writeable {
+
+ /**
+ * The Generic Types which this class can serialize.
+ */
+ public enum SettingType {
+ Boolean,
+ Integer,
+ Long,
+ Float,
+ Double,
+ String,
+ TimeValue, // long + TimeUnit
+ ByteSizeValue, // long + ByteSizeUnit
+ Version
+ }
+
+ private Setting<?> setting;
+ private SettingType type;
+
+ /**
+ * Wrap a {@link Setting}. The generic type is determined from the type of the default value.
+ *
+ * @param setting The setting to wrap. The default value must not be null.
+ * @throws IllegalArgumentException if the setting has a null default value.
+ */
+ public WriteableSetting(Setting<?> setting) {
+ this(setting, getGenericTypeFromDefault(setting));
+ }
+
+ /**
+ * Wrap a {@link Setting} with a specified generic type.
+ *
+ * @param setting The setting to wrap.
+ * @param type The Generic type of the setting.
+ */
+ public WriteableSetting(Setting<?> setting, SettingType type) {
+ this.setting = setting;
+ this.type = type;
+ }
+
+ /**
+ * Wrap a {@link Setting} read from a stream.
+ *
+ * @param in Input to read the value from.
+ * @throws IOException if there is an error reading the values
+ */
+ public WriteableSetting(StreamInput in) throws IOException {
+ // Read the type
+ this.type = in.readEnum(SettingType.class);
+ // Read the key
+ String key = in.readString();
+ // Read the default value
+ Object defaultValue = readDefaultValue(in);
+ // Read a boolean specifying whether the fallback settings is null
+ WriteableSetting fallback = null;
+ boolean hasFallback = in.readBoolean();
+ if (hasFallback) {
+ fallback = new WriteableSetting(in);
+ }
+ // We are using known types so don't need the parser
+ // We are not using validator
+ // Read properties
+ EnumSet<Property> propSet = in.readEnumSet(Property.class);
+ // Put it all in a setting object
+ this.setting = createSetting(type, key, defaultValue, fallback, propSet.toArray(Property[]::new));
+ }
+
+ /**
+ * Due to type erasure, it is impossible to determine the generic type of a Setting at runtime.
+ * All settings have a non-null default, however, so the type of the default can be used to determine the setting type.
+ *
+ * @param setting The setting with a generic type.
+ * @return The corresponding {@link SettingType} for the default value.
+ */
+ private static SettingType getGenericTypeFromDefault(Setting<?> setting) {
+ String typeStr = null;
+ try {
+ // This throws NPE on null default
+ typeStr = setting.getDefault(Settings.EMPTY).getClass().getSimpleName();
+ // This throws IAE if not in enum
+ return SettingType.valueOf(typeStr);
+ } catch (NullPointerException e) {
+ throw new IllegalArgumentException("Unable to determine the generic type of this setting with a null default value.");
+ } catch (IllegalArgumentException e) {
+ throw new UnsupportedOperationException("This class is not yet set up to handle the generic type: " + typeStr);
+ }
+ }
+
+ /**
+ * Gets the wrapped setting. Use {@link #getType()} to determine its generic type.
+ *
+ * @return The wrapped setting.
+ */
+ public Setting<?> getSetting() {
+ return this.setting;
+ }
+
+ /**
+ * Gets the generic type of the wrapped setting.
+ *
+ * @return The wrapped setting's generic type.
+ */
+ public SettingType getType() {
+ return this.type;
+ }
+
+ @SuppressWarnings("unchecked")
+ private Setting<?> createSetting(
+ SettingType genericType,
+ String key,
+ Object defaultValue,
+ WriteableSetting fallback,
+ Property[] propArray
+ ) {
+ switch (genericType) {
+ case Boolean:
+ return fallback == null
+ ? Setting.boolSetting(key, (boolean) defaultValue, propArray)
+ : Setting.boolSetting(key, (Setting<Boolean>) fallback.getSetting(), propArray);
+ case Integer:
+ return fallback == null
+ ? Setting.intSetting(key, (int) defaultValue, propArray)
+ : Setting.intSetting(key, (Setting<Integer>) fallback.getSetting(), propArray);
+ case Long:
+ return fallback == null
+ ? Setting.longSetting(key, (long) defaultValue, propArray)
+ : Setting.longSetting(key, (Setting<Long>) fallback.getSetting(), propArray);
+ case Float:
+ return fallback == null
+ ? Setting.floatSetting(key, (float) defaultValue, propArray)
+ : Setting.floatSetting(key, (Setting<Float>) fallback.getSetting(), propArray);
+ case Double:
+ return fallback == null
+ ? Setting.doubleSetting(key, (double) defaultValue, propArray)
+ : Setting.doubleSetting(key, (Setting<Double>) fallback.getSetting(), propArray);
+ case String:
+ return fallback == null
+ ? Setting.simpleString(key, (String) defaultValue, propArray)
+ : Setting.simpleString(key, (Setting<String>) fallback.getSetting(), propArray);
+ case TimeValue:
+ return fallback == null
+ ? Setting.timeSetting(key, (TimeValue) defaultValue, propArray)
+ : Setting.timeSetting(key, (Setting<TimeValue>) fallback.getSetting(), propArray);
+ case ByteSizeValue:
+ return fallback == null
+ ? Setting.byteSizeSetting(key, (ByteSizeValue) defaultValue, propArray)
+ : Setting.byteSizeSetting(key, (Setting<ByteSizeValue>) fallback.getSetting(), propArray);
+ case Version:
+ // No fallback option on this method
+ return Setting.versionSetting(key, (Version) defaultValue, propArray);
+ default:
+ // This Should Never Happen (TM)
+ throw new UnsupportedOperationException("A SettingType has been added to the enum and not handled here.");
+ }
+ }
+
+ @Override
+ public void writeTo(StreamOutput out) throws IOException {
+ // Write the type
+ out.writeEnum(type);
+ // Write the key
+ out.writeString(setting.getKey());
+ // Write the default value
+ writeDefaultValue(out, setting.getDefault(Settings.EMPTY));
+ // Write a boolean specifying whether the fallback settings is null
+ boolean hasFallback = setting.fallbackSetting != null;
+ out.writeBoolean(hasFallback);
+ if (hasFallback) {
+ new WriteableSetting(setting.fallbackSetting, type).writeTo(out);
+ }
+ // We are using known types so don't need the parser
+ // We are not using validator
+ // Write properties
+ out.writeEnumSet(setting.getProperties());
+ }
+
+ private void writeDefaultValue(StreamOutput out, Object defaultValue) throws IOException {
+ switch (type) {
+ case Boolean:
+ out.writeBoolean((boolean) defaultValue);
+ break;
+ case Integer:
+ out.writeInt((int) defaultValue);
+ break;
+ case Long:
+ out.writeLong((long) defaultValue);
+ break;
+ case Float:
+ out.writeFloat((float) defaultValue);
+ break;
+ case Double:
+ out.writeDouble((double) defaultValue);
+ break;
+ case String:
+ out.writeString((String) defaultValue);
+ break;
+ case TimeValue:
+ TimeValue tv = (TimeValue) defaultValue;
+ out.writeLong(tv.duration());
+ out.writeString(tv.timeUnit().name());
+ break;
+ case ByteSizeValue:
+ ((ByteSizeValue) defaultValue).writeTo(out);
+ break;
+ case Version:
+ Version.writeVersion((Version) defaultValue, out);
+ break;
+ default:
+ // This Should Never Happen (TM)
+ throw new UnsupportedOperationException("A SettingType has been added to the enum and not handled here.");
+ }
+ }
+
+ private Object readDefaultValue(StreamInput in) throws IOException {
+ switch (type) {
+ case Boolean:
+ return in.readBoolean();
+ case Integer:
+ return in.readInt();
+ case Long:
+ return in.readLong();
+ case Float:
+ return in.readFloat();
+ case Double:
+ return in.readDouble();
+ case String:
+ return in.readString();
+ case TimeValue:
+ long duration = in.readLong();
+ TimeUnit unit = TimeUnit.valueOf(in.readString());
+ return new TimeValue(duration, unit);
+ case ByteSizeValue:
+ return new ByteSizeValue(in);
+ case Version:
+ return Version.readVersion(in);
+ default:
+ // This Should Never Happen (TM)
+ throw new UnsupportedOperationException("A SettingType has been added to the enum and not handled here.");
+ }
+ }
+
+ @Override
+ public String toString() {
+ return "WriteableSettings{type=Setting<" + type + ">, setting=" + setting + "}";
+ }
+}

server/src/main/java/org/opensearch/extensions/rest/RegisterRestActionsResponse.java → server/src/main/java/org/opensearch/extensions/ExtensionStringResponse.java

@@ -6,7 +6,7 @@
  * compatible open source license.
  */
 
-package org.opensearch.extensions.rest;
+package org.opensearch.extensions;
 
 import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.common.io.stream.StreamOutput;
@@ -15,18 +15,18 @@
 import java.io.IOException;
 
 /**
- * Response to register REST Actions request.
+ * Generic string response indicating the status of some previous request sent to the SDK
  *
  * @opensearch.internal
  */
-public class RegisterRestActionsResponse extends TransportResponse {
+public class ExtensionStringResponse extends TransportResponse {
  private String response;
 
- public RegisterRestActionsResponse(String response) {
+ public ExtensionStringResponse(String response) {
  this.response = response;
  }
 
- public RegisterRestActionsResponse(StreamInput in) throws IOException {
+ public ExtensionStringResponse(StreamInput in) throws IOException {
  response = in.readString();
  }