[rule based autotagging] add attribute value store

CHANGELOG.md

@@ -42,6 +42,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - [Star Tree] [Search] Resolving Date histogram with metric aggregation using star-tree ([#16674](https://github.com/opensearch-project/OpenSearch/pull/16674))
 - [Star Tree] [Search] Extensible design to support different query and field types ([#17137](https://github.com/opensearch-project/OpenSearch/pull/17137))
 - Improve performace of NumericTermAggregation by avoiding unnecessary sorting([#17252](https://github.com/opensearch-project/OpenSearch/pull/17252))
+- [Rule Based Auto-tagging] Add in-memory attribute value store ([#17342](https://github.com/opensearch-project/OpenSearch/pull/17342))
 
 ### Dependencies
 - Bump `com.google.cloud:google-cloud-core-http` from 2.23.0 to 2.47.0 ([#16504](https://github.com/opensearch-project/OpenSearch/pull/16504))

plugins/workload-management/build.gradle

@@ -19,4 +19,5 @@ opensearchplugin {
 }
 
 dependencies {
+  implementation 'org.apache.commons:commons-collections4:4.4'
 }

plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rule/package-info.java

@@ -0,0 +1,13 @@
+/*
+ * 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.plugin.wlm.rule;
+/**
+ * This package holds constructs for the Rule's in-memory storage, processing and syncing the in-memory view
+ * with the index view
+ */

plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rule/storage/AttributeValueStore.java

@@ -0,0 +1,47 @@
+/*
+ * 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.plugin.wlm.rule.storage;
+
+import java.util.Optional;
+
+/**
+ * This interface provides apis to store Rule attribute values
+ */
+public interface AttributeValueStore<K, V> {
+    /**
+     * Adds the value to the data structure
+     * @param key to be added
+     * @param value to be added
+     */
+    void add(K key, V value);
+
+    /**
+     * removes the key and associated value from the data structure
+     * @param key to be removed
+     */
+    void remove(K key);
+
+    /**
+     * Returns the value associated with the key
+     * @param key in the data structure
+     * @return
+     */
+    Optional<V> get(K key);
+
+    /**
+     * Clears all the keys and their associated values from the structure
+     */
+    void clear();
+
+    /**
+     * It returns the number of values stored
+     * @return count of key,val pairs in the store
+     */
+    int size();
+}

plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rule/storage/DefaultAttributeValueStore.java

@@ -0,0 +1,103 @@
+/*
+ * 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.plugin.wlm.rule.storage;
+
+import org.apache.commons.collections4.trie.PatriciaTrie;
+
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * This is a patricia trie based implementation of AttributeValueStore
+ * We are choosing patricia trie because it provides very fast search operations on prefix matches as well as range
+ * lookups. It provides a very efficient storage for strings
+ * ref: https://commons.apache.org/proper/commons-collections/javadocs/api-4.4/org/apache/commons/collections4/trie/PatriciaTrie.html
+ */
+public class DefaultAttributeValueStore<K extends String, V> implements AttributeValueStore<K, V> {
+    PatriciaTrie<V> trie;
+
+    /**
+     * Default constructor
+     */
+    public DefaultAttributeValueStore() {
+        this(new PatriciaTrie<>());
+    }
+
+    /**
+     * Main constructor
+     * @param trie A Patricia Trie
+     */
+    public DefaultAttributeValueStore(PatriciaTrie<V> trie) {
+        this.trie = trie;
+    }
+
+    @Override
+    public void add(K key, V value) {
+        trie.put(key, value);
+    }
+
+    @Override
+    public void remove(String key) {
+        trie.remove(key);
+    }
+
+    @Override
+    public Optional<V> get(String key) {
+        /**
+         * Since we are inserting prefixes into the trie and searching for larger strings
+         * It is important to find the largest matching prefix key in the trie efficiently
+         * Hence we can do binary search
+         */
+        String longestMatchingPrefix = findLongestMatchingPrefix(key);
+
+        /**
+         * Now there are following cases for this prefix
+         * 1. There is a Rule which has this prefix as one of the attribute values. In this case we should return the
+         *     Rule's label otherwise send empty
+         */
+        for (Map.Entry<String, V> possibleMatch : trie.prefixMap(longestMatchingPrefix).entrySet()) {
+            if (key.startsWith(possibleMatch.getKey())) {
+                return Optional.of(possibleMatch.getValue());
+            }
+        }
+
+        return Optional.empty();
+    }
+
+    private String findLongestMatchingPrefix(String key) {
+        int low = 0;
+        int high = key.length() - 1;
+
+        while (low < high) {
+            int mid = low + (high - low + 1) / 2;
+            String possibleMatchingPrefix = key.substring(0, mid);
+
+            /**
+             * This operation has O(1) complexity because prefixMap returns only the iterator
+             */
+            if (!trie.prefixMap(possibleMatchingPrefix).isEmpty()) {
+                low = mid;
+            } else {
+                high = mid - 1;
+            }
+        }
+
+        return key.substring(0, low);
+    }
+
+    @Override
+    public void clear() {
+        trie.clear();
+    }
+
+    @Override
+    public int size() {
+        return trie.size();
+    }
+}

plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rule/storage/package-info.java

@@ -0,0 +1,12 @@
+/*
+ * 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.plugin.wlm.rule.storage;
+/**
+ * This package contains interfaces and implementations for in memory rule storage mechanisms
+ */

plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/rule/storage/AttributeValueStoreTests.java

@@ -0,0 +1,53 @@
+/*
+ * 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.plugin.wlm.rule.storage;
+
+import org.apache.commons.collections4.trie.PatriciaTrie;
+import org.opensearch.test.OpenSearchTestCase;
+
+public class AttributeValueStoreTests extends OpenSearchTestCase {
+
+    AttributeValueStore<String, String> subjectUnderTest;
+
+    public void setUp() throws Exception {
+        super.setUp();
+        subjectUnderTest = new DefaultAttributeValueStore<>(new PatriciaTrie<>());
+    }
+
+    public void testAdd() {
+        subjectUnderTest.add("foo", "bar");
+        assertEquals("bar", subjectUnderTest.get("foo").get());
+    }
+
+    public void testRemove() {
+        subjectUnderTest.add("foo", "bar");
+        subjectUnderTest.remove("foo");
+        assertEquals(0, subjectUnderTest.size());
+    }
+
+    public void tesGet() {
+        subjectUnderTest.add("foo", "bar");
+        assertEquals("bar", subjectUnderTest.get("foo").get());
+    }
+
+    public void testGetWhenNoProperPrefixIsPresent() {
+        subjectUnderTest.add("foo", "bar");
+        subjectUnderTest.add("foodip", "sing");
+        assertTrue(subjectUnderTest.get("foxtail").isEmpty());
+        subjectUnderTest.add("fox", "lucy");
+
+        assertFalse(subjectUnderTest.get("foxtail").isEmpty());
+    }
+
+    public void testClear() {
+        subjectUnderTest.add("foo", "bar");
+        subjectUnderTest.clear();
+        assertEquals(0, subjectUnderTest.size());
+    }
+}