libglusterfs, glusterfsd: add shortname resolution + optname hinting support to VOLUME SET

Trie code used for hinting is contributed by Avati.

Signed-off-by: Csaba Henk <csaba@lowlife.hu>
Signed-off-by: Anand V. Avati <avati@dev.gluster.com>

BUG: 1750 (clean up volgen)
URL: http://bugs.gluster.com/cgi-bin/bugzilla3/show_bug.cgi?id=1750

2 files changed, 284 insertions, 31 deletions

diff --git a/xlators/mgmt/glusterd/src/glusterd-op-sm.c b/xlators/mgmt/glusterd/src/glusterd-op-sm.c
index d19caddc63c..e57acf1d235 100644
--- a/xlators/mgmt/glusterd/src/glusterd-op-sm.c
+++ b/xlators/mgmt/glusterd/src/glusterd-op-sm.c
@@ -1123,6 +1123,7 @@ glusterd_op_stage_set_volume (gd1_mgmt_stage_op_req *req, char **op_errstr)
         char                                    *volname       = NULL;
  	int                                      exists        = 0;
  	char					*key	       = NULL;
+        char                                    *key_fixed     = NULL;
         char                                    *value         = NULL;
  	char					 str[100]      = {0, };
  	int					 count	       = 0;
@@ -1204,13 +1205,20 @@ glusterd_op_stage_set_volume (gd1_mgmt_stage_op_req *req, char **op_errstr)
                         break;
 
 		
-		exists = glusterd_check_option_exists (key, NULL);
-
-		if (exists != 1) {
+		exists = glusterd_check_option_exists (key, &key_fixed);
+                if (exists == -1) {
+                        ret = -1;
+                        goto out;
+                }
+		if (!exists) {
                 	gf_log ("", GF_LOG_ERROR, "Option with name: %s "
                         	"does not exist", key);
-                        snprintf (errstr, 2048, "option : %s does not exist",
-                                  key);
+                        ret = snprintf (errstr, 2048,
+                                       "option : %s does not exist",
+                                       key);
+                        if (key_fixed)
+                                snprintf (errstr + ret, 2048 - ret,
+                                          "\nDid you mean %s?", key_fixed);
                         *op_errstr = gf_strdup (errstr);
 
 			ret = -1;
@@ -1227,6 +1235,8 @@ glusterd_op_stage_set_volume (gd1_mgmt_stage_op_req *req, char **op_errstr)
                         goto out;
                 }
 
+                if (key_fixed)
+                        key = key_fixed;
                 ret = dict_set_str (val_dict, key, value);
 
                 if (ret) {
@@ -1236,7 +1246,10 @@ glusterd_op_stage_set_volume (gd1_mgmt_stage_op_req *req, char **op_errstr)
                         goto out;
                 }
 
-
+                if (key_fixed) {
+                        GF_FREE (key_fixed);
+                        key_fixed = NULL;
+                }
 	}
 
         *op_errstr = NULL;
@@ -1258,6 +1271,9 @@ out:
         if (val_dict)
                 dict_unref (val_dict);
 
+        if (key_fixed)
+                GF_FREE (key_fixed);
+
         if (ret) {
                 if (!(*op_errstr)) {
                         *op_errstr = gf_strdup ("Error, Validation Failed");
@@ -1269,7 +1285,7 @@ out:
                         gf_log ("glsuterd", GF_LOG_DEBUG,
                         "Error, Cannot Validate option");
         }
-return ret;
+        return ret;
 }
 
 static int
@@ -3196,6 +3212,7 @@ glusterd_op_set_volume (gd1_mgmt_stage_op_req *req)
         glusterd_conf_t                         *priv = NULL;
 	int					 count = 1;
 	char					*key = NULL;
+	char					*key_fixed = NULL;
 	char					*value = NULL;
 	char					 str[50] = {0, };
         GF_ASSERT (req);
@@ -3234,7 +3251,15 @@ glusterd_op_set_volume (gd1_mgmt_stage_op_req *req)
 
 		sprintf (str, "key%d", count);
 		ret = dict_get_str (dict, str, &key);
-
+                if (!ret) {
+                        ret = glusterd_check_option_exists (key, &key_fixed);
+                        GF_ASSERT (ret);
+                        if (ret == -1) {
+                                key_fixed = NULL;
+                                goto out;
+                        }
+                        ret = 0;
+                }
 
 		if (ret)
 			break;
@@ -3250,9 +3275,11 @@ glusterd_op_set_volume (gd1_mgmt_stage_op_req *req)
         	}
 
                 value = gf_strdup (value);
-                if (value)
+                if (value) {
+                        if (key_fixed)
+                                key = key_fixed;
 		        ret = dict_set_dynstr (volinfo->dict, key, value);
-                else
+                } else
                         ret = -1;
 
 		if (ret) {
@@ -3261,6 +3288,11 @@ glusterd_op_set_volume (gd1_mgmt_stage_op_req *req)
 			ret = -1;
 			goto out;
         	}
+
+                if (key_fixed) {
+                        GF_FREE (key_fixed);
+                        key_fixed = NULL;
+                }
 	}
 
 	if ( count == 1 ) {
@@ -3294,6 +3326,8 @@ glusterd_op_set_volume (gd1_mgmt_stage_op_req *req)
 out:
         if (dict)
                 dict_unref (dict);
+        if (key_fixed)
+                GF_FREE (key_fixed);
         gf_log ("", GF_LOG_DEBUG, "returning %d", ret);
         return ret;
 }
diff --git a/xlators/mgmt/glusterd/src/glusterd-volgen.c b/xlators/mgmt/glusterd/src/glusterd-volgen.c
index 42e2f63772c..16f4b92e514 100644
--- a/xlators/mgmt/glusterd/src/glusterd-volgen.c
+++ b/xlators/mgmt/glusterd/src/glusterd-volgen.c
@@ -31,6 +31,7 @@
 #include "logging.h"
 #include "dict.h"
 #include "graph-utils.h"
+#include "trie.h"
 #include "glusterd-mem-types.h"
 #include "cli1.h"
 #include "glusterd-volgen.h"
@@ -336,6 +337,193 @@ first_of (glusterfs_graph_t *graph)
 
 /**************************
  *
+ * Trie glue
+ *
+ *************************/
+
+
+static int
+volopt_selector (int lvl, char **patt, void *param,
+                     int (*optcbk)(char *word, void *param))
+{
+        struct volopt_map_entry *vme = NULL;
+        char *w = NULL;
+        int i = 0;
+        int len = 0;
+        int ret = 0;
+        char *dot = NULL;
+
+        for (vme = glusterd_volopt_map; vme->key; vme++) {
+                w = vme->key;
+
+                for (i = 0; i < lvl; i++) {
+                        if (patt[i]) {
+                                w = strtail (w, patt[i]);
+                                GF_ASSERT (!w || *w);
+                                if (!w || *w != '.')
+                                        goto next;
+                        } else {
+                                w = strchr (w, '.');
+                                GF_ASSERT (w);
+                        }
+                        w++;
+                }
+
+                dot = strchr (w, '.');
+                if (dot) {
+                        len = dot - w;
+                        w = gf_strdup (w);
+                        if (!w)
+                                return -1;
+                        w[len] = '\0';
+                }
+                ret = optcbk (w, param);
+                if (dot)
+                        GF_FREE (w);
+                if (ret)
+                        return -1;
+ next:
+                continue;
+        }
+
+        return 0;
+}
+
+static int
+volopt_trie_cbk (char *word, void *param)
+{
+        return trie_add ((trie_t *)param, word);
+}
+
+static int
+process_nodevec (struct trienodevec *nodevec, char **hint)
+{
+        int ret = 0;
+        char *hint1 = NULL;
+        char *hint2 = NULL;
+        char *hintinfx = "";
+        trienode_t **nodes = nodevec->nodes;
+
+        if (!nodes[0]) {
+                *hint = NULL;
+                return 0;
+        }
+
+#if 0
+        /* Limit as in git */
+        if (trienode_get_dist (nodes[0]) >= 6) {
+                *hint = NULL;
+                return 0;
+        }
+#endif
+
+        if (trienode_get_word (nodes[0], &hint1))
+                return -1;
+
+        if (nodevec->cnt < 2 || !nodes[1]) {
+                *hint = hint1;
+                return 0;
+        }
+
+        if (trienode_get_word (nodes[1], &hint2))
+                return -1;
+
+        if (*hint)
+                hintinfx = *hint;
+        ret = gf_asprintf (hint, "%s or %s%s", hint1, hintinfx, hint2);
+        if (ret > 0)
+                ret = 0;
+        return ret;
+}
+
+static int
+volopt_trie_section (int lvl, char **patt, char *word, char **hint, int hints)
+{
+        trienode_t *nodes[] = { NULL, NULL };
+        struct trienodevec nodevec = { nodes, 2};
+        trie_t *trie = NULL;
+        int ret = 0;
+
+        trie = trie_new ();
+        if (!trie)
+                return -1;
+
+        if (volopt_selector (lvl, patt, trie, &volopt_trie_cbk)) {
+                trie_destroy (trie);
+
+                return -1;
+        }
+
+        GF_ASSERT (hints <= 2);
+        nodevec.cnt = hints;
+        ret = trie_measure_vec (trie, word, &nodevec);
+        if (ret || !nodevec.nodes[0])
+                trie_destroy (trie);
+
+        ret = process_nodevec (&nodevec, hint);
+        trie_destroy (trie);
+
+        return ret;
+}
+
+static int
+volopt_trie (char *key, char **hint)
+{
+        char *patt[] = { NULL };
+        char *fullhint = NULL;
+        char *dot = NULL;
+        char *dom = NULL;
+        int   len = 0;
+        int   ret = 0;
+
+        *hint = NULL;
+
+        dot = strchr (key, '.');
+        if (!dot)
+                return volopt_trie_section (1, patt, key, hint, 2);
+
+        len = dot - key;
+        dom = gf_strdup (key);
+        if (!dom)
+                return -1;
+        dom[len] = '\0';
+
+        ret = volopt_trie_section (0, NULL, dom, patt, 1);
+        GF_FREE (dom);
+        if (ret) {
+                patt[0] = NULL;
+                goto out;
+        }
+        if (!patt[0])
+                goto out;
+
+        *hint = "...";
+        ret = volopt_trie_section (1, patt, dot + 1, hint, 2);
+        if (ret)
+                goto out;
+        if (*hint) {
+                ret = gf_asprintf (&fullhint, "%s.%s", patt[0], *hint);
+                GF_FREE (*hint);
+                if (ret >= 0) {
+                        ret = 0;
+                        *hint = fullhint;
+                }
+        }
+
+ out:
+        if (patt[0])
+                GF_FREE (patt[0]);
+        if (ret)
+                *hint = NULL;
+
+        return ret;
+}
+
+
+
+
+/**************************
+ *
  * Volume generation engine
  *
  **************************/
@@ -502,23 +690,35 @@ glusterd_volinfo_get (glusterd_volinfo_t *volinfo, char *key, char **value)
         return 0;
 }
 
-static char *
-option_complete (char *key)
+static int
+option_complete (char *key, char **completion)
 {
         struct volopt_map_entry *vme = NULL;
-        char *completion = NULL;
 
+        *completion = NULL;
         for (vme = glusterd_volopt_map; vme->key; vme++) {
                 if (strcmp (strchr (vme->key, '.') + 1, key) != 0)
                         continue;
 
-                if (completion)
-                        return NULL;
-                else
-                        completion = vme->key;
+                if (*completion && strcmp (*completion, vme->key) != 0) {
+                        /* cancel on non-unique match */
+                        *completion = NULL;
+
+                        return 0;
+                } else
+                        *completion = vme->key;
         }
 
-        return completion;
+        if (*completion) {
+                /* For sake of unified API we want
+                 * have the completion to be a to-be-freed
+                 * string.
+                 */
+                *completion = gf_strdup (*completion);
+                return -!*completion;
+        }
+
+        return 0;
 }
 
 int
@@ -535,9 +735,17 @@ glusterd_check_option_exists (char *key, char **completion)
 
         if (!strchr (key, '.')) {
                 if (completion) {
-                        *completion = option_complete (key);
+                        ret = option_complete (key, completion);
+                        if (ret) {
+                                gf_log ("", GF_LOG_ERROR, "Out of memory");
+                                return -1;
+                        }
 
-                        return !!*completion;
+                        ret = !!*completion;
+                        if (ret)
+                                return ret;
+                        else
+                                goto trie;
                 } else
                         return 0;
         }
@@ -549,8 +757,6 @@ glusterd_check_option_exists (char *key, char **completion)
                         break;
                 }
         }
-
-        return ret;
 #else
         vme.key = key;
 
@@ -563,22 +769,35 @@ glusterd_check_option_exists (char *key, char **completion)
          * have to update the fnmatch in this comment also :P ]]
          */
         dict = get_new_dict ();
-        if (!dict || dict_set_str (dict, key, ""))
-                goto oom;
+        if (!dict || dict_set_str (dict, key, "")) {
+                gf_log ("", GF_LOG_ERROR, "Out of memory");
+
+                return -1;
+        }
 
         ret = volgen_graph_set_options_generic (NULL, dict, &vme,
                                                 &optget_option_handler);
         dict_destroy (dict);
-        if (ret)
-                goto oom;
-
-        return !!vme.value;
+        if (ret) {
+                gf_log ("", GF_LOG_ERROR, "Out of memory");
 
- oom:
-        gf_log ("", GF_LOG_ERROR, "Out of memory");
+                return -1;
+        }
 
-        return -1;
+        ret = !!vme.value;
 #endif
+
+        if (ret || !completion)
+                return ret;
+
+ trie:
+        ret = volopt_trie (key, completion);
+        if (ret) {
+                gf_log ("", GF_LOG_ERROR,
+                        "Some error occured during keyword hinting");
+        }
+
+        return ret;
 }
 
 static int