WriteableSetting wrapper class and RegisterSettingsRequest

Signed-off-by: Daniel Widdis <[email protected]>

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

@@ -0,0 +1,305 @@
+/*
+ * 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.common.bytes.BytesReference;
+import org.opensearch.common.io.stream.BytesStreamInput;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+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.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 WriteableSettingGenericType {
+ Boolean,
+ Integer,
+ Long,
+ Float,
+ Double,
+ String,
+ TimeValue, // long + TimeUnit
+ ByteSizeValue // long + ByteSizeUnit
+ }
+
+ private Setting<?> setting;
+ private WriteableSettingGenericType 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, WriteableSettingGenericType 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 = WriteableSettingGenericType.valueOf(in.readString());
+ // 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
+ int size = in.readVInt();
+ Property[] propArray = new Property[size];
+ for (int i = 0; i < size; i++) {
+ propArray[i] = Property.valueOf(in.readString());
+ }
+ // Put it all in a setting object
+ this.setting = createSetting(type, key, defaultValue, fallback, propArray);
+ }
+
+ private static WriteableSettingGenericType getGenericTypeFromDefault(Setting<?> setting) {
+ Object defaultValue = setting.getDefault(Settings.EMPTY);
+ if (defaultValue == null) {
+ throw new IllegalArgumentException("Unable to determine the generic type of this setting with a null default value.");
+ }
+ String typeStr = defaultValue.getClass().getSimpleName();
+ try {
+ return WriteableSettingGenericType.valueOf(typeStr);
+ } 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 WriteableSettingGenericType getType() {
+ return this.type;
+ }
+
+ @SuppressWarnings("unchecked")
+ private Setting<?> createSetting(
+ WriteableSettingGenericType 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);
+ default:
+ // This Should Never Happen (TM)
+ throw new UnsupportedOperationException("A WriteableSettingGenericType has been added to the enum and not handled here.");
+ }
+ }
+
+ @Override
+ public void writeTo(StreamOutput out) throws IOException {
+ // Write the type
+ out.writeString(type.name());
+ // 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.writeVInt(setting.getProperties().size());
+ for (Property prop : setting.getProperties()) {
+ out.writeString(prop.name());
+ }
+ }
+
+ 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;
+ default:
+ // This Should Never Happen (TM)
+ throw new UnsupportedOperationException("A WriteableSettingGenericType 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);
+ default:
+ // This Should Never Happen (TM)
+ throw new UnsupportedOperationException("A WriteableSettingGenericType has been added to the enum and not handled here.");
+ }
+ }
+
+ @Override
+ public String toString() {
+ return "WriteableSettings{type=Setting<" + type + ">, setting=" + setting + "}";
+ }
+
+ public static void main(String... args) throws IOException {
+ // TEMPORARY, this will be moved to a test class
+
+ // LegacyOpenDistroAnomalyDetectorSettings.MAX_RETRY_FOR_END_RUN_EXCEPTION
+ // Note this provides default value of 6
+ Setting<Integer> fallbackSetting = Setting.intSetting(
+ "opendistro.anomaly_detection.max_retry_for_end_run_exception",
+ 6,
+ 0,
+ Setting.Property.NodeScope,
+ Setting.Property.Dynamic // ,
+ // Fails if we try to use it
+ // Setting.Property.Deprecated
+ );
+
+ System.out.println("Original with fallback");
+ // AnomalyDetectorSetting.MAX_RETRY_FOR_END_RUN_EXCEPTION
+ // Note this falls back to the other setting
+ // This populates the default value since we have no settings, although it won't be used
+ Setting<Integer> intSetting = Setting.intSetting(
+ "plugins.anomaly_detection.max_retry_for_end_run_exception",
+ fallbackSetting,
+ 0,
+ Setting.Property.NodeScope,
+ Setting.Property.Dynamic
+ );
+ System.out.println("Original");
+ System.out.println(intSetting.toString());
+
+ WriteableSetting wsOut = new WriteableSetting(intSetting);
+ try (BytesStreamOutput out = new BytesStreamOutput()) {
+ wsOut.writeTo(out);
+ out.flush();
+ try (BytesStreamInput in = new BytesStreamInput(BytesReference.toBytes(out.bytes()))) {
+ WriteableSetting wsIn = new WriteableSetting(in);
+ System.out.println("After transport across a (byte)stream");
+ System.out.println(wsIn.toString());
+ }
+ }
+ }
+}

server/src/main/java/org/opensearch/extensions/settings/RegisterSettingsRequest.java

@@ -11,6 +11,7 @@
 import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.common.io.stream.StreamOutput;
 import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.WriteableSetting;
 import org.opensearch.transport.TransportRequest;
 
 import java.io.IOException;
@@ -34,8 +35,14 @@ public RegisterSettingsRequest(String uniqueId, List<Setting<?>> settings) {
 
  public RegisterSettingsRequest(StreamInput in) throws IOException {
  super(in);
- uniqueId = in.readString();
- // TODO add vInt and read N settings
+ this.uniqueId = in.readString();
+ int size = in.readVInt();
+ List<Setting<?>> settingsList = new ArrayList<>(size);
+ for (int i = 0; i < size; i++) {
+ WriteableSetting ws = new WriteableSetting(in);
+ settingsList.add(ws.getSetting());
+ }
+ this.settings = settingsList;
  }
 
  @Override
@@ -44,9 +51,8 @@ public void writeTo(StreamOutput out) throws IOException {
  out.writeString(uniqueId);
  out.writeVInt(settings.size());
  for (Setting<?> setting : settings) {
- setting.getDefault(null);
+ new WriteableSetting(setting).writeTo(out);
  }
- // TODO add vINt and write N settings
  }
 
  public String getUniqueId() {
@@ -59,7 +65,7 @@ public List<Setting<?>> getSettings() {
 
  @Override
  public String toString() {
- return "RegisterSettingsRequest{uniqueId=" + uniqueId + ", settingss=" + settings + "}";
+ return "RegisterSettingsRequest{uniqueId=" + uniqueId + ", settings=" + settings + "}";
  }
 
  @Override