make the store interface generic

Signed-off-by: Kaushal Kumar <[email protected]>

Author: kaushalmahi12

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

@@ -13,26 +13,26 @@
 /**
  * This interface provides apis to store Rule attribute values
  */
-public interface AttributeValueStore {
+public interface AttributeValueStore<K, V> {
     /**
      * Adds the value to the data structure
      * @param key to be added
      * @param value to be added
      */
-    void addValue(String key, String value);
+    void add(K key, V value);
 
     /**
      * removes the key and associated value from the data structure
      * @param key to be removed
      */
-    void removeValue(String key);
+    void remove(K key);
 
     /**
      * Returns the value associated with the key
      * @param key in the data structure
      * @return
      */
-    Optional<String> getValue(String key);
+    Optional<V> get(K key);
 
     /**
      * Clears all the keys and their associated values from the structure

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

@@ -15,26 +15,29 @@
 
 /**
  * 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 TrieBasedStore implements AttributeValueStore {
-    PatriciaTrie<String> trie;
+public class DefaultAttributeValueStore<K extends String, V> implements AttributeValueStore<K, V> {
+    PatriciaTrie<V> trie;
 
-    public TrieBasedStore(PatriciaTrie<String> trie) {
+    public DefaultAttributeValueStore(PatriciaTrie<V> trie) {
         this.trie = trie;
     }
 
     @Override
-    public void addValue(String key, String value) {
+    public void add(K key, V value) {
         trie.put(key, value);
     }
 
     @Override
-    public void removeValue(String key) {
+    public void remove(String key) {
         trie.remove(key);
     }
 
     @Override
-    public Optional<String> getValue(String key) {
+    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
@@ -47,7 +50,7 @@ public Optional<String> getValue(String key) {
          * 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, String> possibleMatch :trie.prefixMap(longestMatchingPrefix).entrySet()) {
+        for (Map.Entry<String, V> possibleMatch :trie.prefixMap(longestMatchingPrefix).entrySet()) {
             if (key.startsWith(possibleMatch.getKey())) {
                 return Optional.of(possibleMatch.getValue());
             }
@@ -64,6 +67,9 @@ private String findLongestMatchingPrefix(String key) {
             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 {

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

@@ -14,41 +14,41 @@
 
 public class AttributeValueStoreTests extends OpenSearchTestCase {
 
-    AttributeValueStore subjectUnderTest;
+    AttributeValueStore<String, String> subjectUnderTest;
 
     public void setUp() throws Exception {
         super.setUp();
-        subjectUnderTest = new TrieBasedStore(new PatriciaTrie<>());
+        subjectUnderTest = new DefaultAttributeValueStore<>(new PatriciaTrie<>());
     }
 
-    public void testAddValue() {
-        subjectUnderTest.addValue("foo", "bar");
-        assertEquals("bar", subjectUnderTest.getValue("foo").get());
+    public void testAdd() {
+        subjectUnderTest.add("foo", "bar");
+        assertEquals("bar", subjectUnderTest.get("foo").get());
     }
 
-    public void testRemoveValue() {
-        subjectUnderTest.addValue("foo", "bar");
-        subjectUnderTest.removeValue("foo");
+    public void testRemove() {
+        subjectUnderTest.add("foo", "bar");
+        subjectUnderTest.remove("foo");
         assertEquals(0, subjectUnderTest.size());
     }
 
-    public void tesGetValue() {
-        subjectUnderTest.addValue("foo", "bar");
-        assertEquals("bar", subjectUnderTest.getValue("foo").get());
+    public void tesGet() {
+        subjectUnderTest.add("foo", "bar");
+        assertEquals("bar", subjectUnderTest.get("foo").get());
     }
 
-    public void testGetValueWhenNoProperPrefixIsPresent() {
-        subjectUnderTest.addValue("foo", "bar");
-        subjectUnderTest.addValue("foodip", "sing");
-        assertTrue(subjectUnderTest.getValue("foxtail").isEmpty());
-        subjectUnderTest.addValue("fox", "lucy");
+    public void testGetWhenNoProperPrefixIsPresent() {
+        subjectUnderTest.add("foo", "bar");
+        subjectUnderTest.add("foodip", "sing");
+        assertTrue(subjectUnderTest.get("foxtail").isEmpty());
+        subjectUnderTest.add("fox", "lucy");
 
-        assertFalse(subjectUnderTest.getValue("foxtail").isEmpty());
+        assertFalse(subjectUnderTest.get("foxtail").isEmpty());
     }
 
 
     public void testClear() {
-        subjectUnderTest.addValue("foo", "bar");
+        subjectUnderTest.add("foo", "bar");
         subjectUnderTest.clear();
         assertEquals(0, subjectUnderTest.size());
     }