From 1029c27982d2f91cb2d3c4fcc19aa5171111dfb9 Mon Sep 17 00:00:00 2001

From: Jiffin Tony Thottan <jthottan@redhat.com>

Date: Mon, 16 Oct 2017 14:24:29 +0530

Subject: [PATCH 054/124] Revert "glusterd: (storhaug) remove ganesha"

This reverts commit 843e1b04b554ab887ec656ae7b468bb93ee4e2f7.

Label: DOWNSTREAM ONLY

Change-Id: I06b5450344c33f26da3d94b6f67051d41dfbba17

Signed-off-by: Jiffin Tony Thottan <jthottan@redhat.com>

Reviewed-on: https://code.engineering.redhat.com/gerrit/167103

Reviewed-by: Soumya Koduri <skoduri@redhat.com>

Tested-by: RHGS Build Bot <nigelb@redhat.com>

Reviewed-by: Sunil Kumar Heggodu Gopala Acharya <sheggodu@redhat.com>

---

 cli/src/cli-cmd-global.c                           |  57 ++

 cli/src/cli-cmd-parser.c                           | 122 ++-

 cli/src/cli-cmd.c                                  |   3 +-

 cli/src/cli-rpc-ops.c                              |  82 ++

 cli/src/cli.h                                      |   4 +

 xlators/mgmt/glusterd/src/Makefile.am              |   4 +-

 xlators/mgmt/glusterd/src/glusterd-errno.h         |   2 +-

 xlators/mgmt/glusterd/src/glusterd-ganesha.c       | 915 +++++++++++++++++++++

 xlators/mgmt/glusterd/src/glusterd-handler.c       |  79 ++

 xlators/mgmt/glusterd/src/glusterd-messages.h      |   2 +-

 xlators/mgmt/glusterd/src/glusterd-op-sm.c         |  45 +-

 .../mgmt/glusterd/src/glusterd-snapshot-utils.c    | 196 +++++

 xlators/mgmt/glusterd/src/glusterd-store.h         |   2 +

 xlators/mgmt/glusterd/src/glusterd-volume-ops.c    |  37 +

 xlators/mgmt/glusterd/src/glusterd-volume-set.c    |   7 +

 xlators/mgmt/glusterd/src/glusterd.h               |  22 +

 16 files changed, 1568 insertions(+), 11 deletions(-)

 create mode 100644 xlators/mgmt/glusterd/src/glusterd-ganesha.c

diff --git a/cli/src/cli-cmd-global.c b/cli/src/cli-cmd-global.c

index d0729ac..270b76f 100644

--- a/cli/src/cli-cmd-global.c

+++ b/cli/src/cli-cmd-global.c

@@ -36,6 +36,10 @@ int

 cli_cmd_get_state_cbk(struct cli_state *state, struct cli_cmd_word *word,

                       const char **words, int wordcount);

+int

+cli_cmd_ganesha_cbk(struct cli_state *state, struct cli_cmd_word *word,

+                    const char **words, int wordcount);

+

 struct cli_cmd global_cmds[] = {

     {

         "global help",

@@ -48,6 +52,11 @@ struct cli_cmd global_cmds[] = {

         cli_cmd_get_state_cbk,

         "Get local state representation of mentioned daemon",

     },

+    {

+        "nfs-ganesha {enable| disable} ",

+        cli_cmd_ganesha_cbk,

+        "Enable/disable NFS-Ganesha support",

+    },

     {NULL, NULL, NULL}};

 int

@@ -89,6 +98,54 @@ out:

 }

 int

+cli_cmd_ganesha_cbk(struct cli_state *state, struct cli_cmd_word *word,

+                    const char **words, int wordcount)

+

+{

+    int sent = 0;

+    int parse_error = 0;

+    int ret = -1;

+    rpc_clnt_procedure_t *proc = NULL;

+    call_frame_t *frame = NULL;

+    dict_t *options = NULL;

+    cli_local_t *local = NULL;

+    char *op_errstr = NULL;

+

+    proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GANESHA];

+

+    frame = create_frame(THIS, THIS->ctx->pool);

+    if (!frame)

+        goto out;

+

+    ret = cli_cmd_ganesha_parse(state, words, wordcount, &options, &op_errstr);

+    if (ret) {

+        if (op_errstr) {

+            cli_err("%s", op_errstr);

+            GF_FREE(op_errstr);

+        } else

+            cli_usage_out(word->pattern);

+        parse_error = 1;

+        goto out;

+    }

+

+    CLI_LOCAL_INIT(local, words, frame, options);

+

+    if (proc->fn) {

+        ret = proc->fn(frame, THIS, options);

+    }

+

+out:

+    if (ret) {

+        cli_cmd_sent_status_get(&sent);

+        if ((sent == 0) && (parse_error == 0))

+            cli_out("Setting global option failed");

+    }

+

+    CLI_STACK_DESTROY(frame);

+    return ret;

+}

+

+int

 cli_cmd_get_state_cbk(struct cli_state *state, struct cli_cmd_word *word,

                       const char **words, int wordcount)

 {

diff --git a/cli/src/cli-cmd-parser.c b/cli/src/cli-cmd-parser.c

index d9ccba1..cd9c445 100644

--- a/cli/src/cli-cmd-parser.c

+++ b/cli/src/cli-cmd-parser.c

@@ -1694,7 +1694,7 @@ cli_cmd_volume_set_parse(struct cli_state *state, const char **words,

             }

         }

-        if ((strcmp (key, "cluster.brick-multiplex") == 0)) {

+        if ((strcmp(key, "cluster.brick-multiplex") == 0)) {

             question =

                 "Brick-multiplexing is supported only for "

                 "OCS converged or independent mode. Also it is "

@@ -1703,11 +1703,12 @@ cli_cmd_volume_set_parse(struct cli_state *state, const char **words,

                 "are running before this option is modified."

                 "Do you still want to continue?";

-            answer = cli_cmd_get_confirmation (state, question);

+            answer = cli_cmd_get_confirmation(state, question);

             if (GF_ANSWER_NO == answer) {

-                gf_log ("cli", GF_LOG_ERROR, "Operation "

-                        "cancelled, exiting");

-                *op_errstr = gf_strdup ("Aborted by user.");

+                gf_log("cli", GF_LOG_ERROR,

+                       "Operation "

+                       "cancelled, exiting");

+                *op_errstr = gf_strdup("Aborted by user.");

                 ret = -1;

                 goto out;

             }

@@ -5848,3 +5849,114 @@ out:

     return ret;

 }

+

+/* Parsing global option for NFS-Ganesha config

+ *  gluster nfs-ganesha enable/disable */

+

+int32_t

+cli_cmd_ganesha_parse(struct cli_state *state, const char **words,

+                      int wordcount, dict_t **options, char **op_errstr)

+{

+    dict_t *dict = NULL;

+    int ret = -1;

+    char *key = NULL;

+    char *value = NULL;

+    char *w = NULL;

+    char *opwords[] = {"enable", "disable", NULL};

+    const char *question = NULL;

+    gf_answer_t answer = GF_ANSWER_NO;

+

+    GF_ASSERT(words);

+    GF_ASSERT(options);

+

+    dict = dict_new();

+

+    if (!dict)

+        goto out;

+

+    if (wordcount != 2)

+        goto out;

+

+    key = (char *)words[0];

+    value = (char *)words[1];

+

+    if (!key || !value) {

+        cli_out("Usage : nfs-ganesha <enable/disable>");

+        ret = -1;

+        goto out;

+    }

+

+    ret = gf_strip_whitespace(value, strlen(value));

+    if (ret == -1)

+        goto out;

+

+    if (strcmp(key, "nfs-ganesha")) {

+        gf_asprintf(op_errstr,

+                    "Global option: error: ' %s '"

+                    "is not a valid global option.",

+                    key);

+        ret = -1;

+        goto out;

+    }

+

+    w = str_getunamb(value, opwords);

+    if (!w) {

+        cli_out(

+            "Invalid global option \n"

+            "Usage : nfs-ganesha <enable/disable>");

+        ret = -1;

+        goto out;

+    }

+

+    question =

+        "Enabling NFS-Ganesha requires Gluster-NFS to be"

+        " disabled across the trusted pool. Do you "

+        "still want to continue?\n";

+

+    if (strcmp(value, "enable") == 0) {

+        answer = cli_cmd_get_confirmation(state, question);

+        if (GF_ANSWER_NO == answer) {

+            gf_log("cli", GF_LOG_ERROR,

+                   "Global operation "

+                   "cancelled, exiting");

+            ret = -1;

+            goto out;

+        }

+    }

+    cli_out("This will take a few minutes to complete. Please wait ..");

+

+    ret = dict_set_str(dict, "key", key);

+    if (ret) {

+        gf_log(THIS->name, GF_LOG_ERROR, "dict set on key failed");

+        goto out;

+    }

+

+    ret = dict_set_str(dict, "value", value);

+    if (ret) {

+        gf_log(THIS->name, GF_LOG_ERROR, "dict set on value failed");

+        goto out;

+    }

+

+    ret = dict_set_str(dict, "globalname", "All");

+    if (ret) {

+        gf_log(THIS->name, GF_LOG_ERROR,

+               "dict set on global"

+               " key failed.");

+        goto out;

+    }

+

+    ret = dict_set_int32(dict, "hold_global_locks", _gf_true);

+    if (ret) {

+        gf_log(THIS->name, GF_LOG_ERROR,

+               "dict set on global key "

+               "failed.");

+        goto out;

+    }

+

+    *options = dict;

+out:

+    if (ret)

+        dict_unref(dict);

+

+    return ret;

+}

diff --git a/cli/src/cli-cmd.c b/cli/src/cli-cmd.c

index 2ee8b1b..8c06905 100644

--- a/cli/src/cli-cmd.c

+++ b/cli/src/cli-cmd.c

@@ -366,7 +366,8 @@ cli_cmd_submit(struct rpc_clnt *rpc, void *req, call_frame_t *frame,

     unsigned timeout = 0;

     if ((GLUSTER_CLI_PROFILE_VOLUME == procnum) ||

-        (GLUSTER_CLI_HEAL_VOLUME == procnum))

+        (GLUSTER_CLI_HEAL_VOLUME == procnum) ||

+        (GLUSTER_CLI_GANESHA == procnum))

         timeout = cli_ten_minutes_timeout;

     else

         timeout = cli_default_conn_timeout;

diff --git a/cli/src/cli-rpc-ops.c b/cli/src/cli-rpc-ops.c

index 12e7fcc..736cd18 100644

--- a/cli/src/cli-rpc-ops.c

+++ b/cli/src/cli-rpc-ops.c

@@ -2207,6 +2207,62 @@ out:

     return ret;

 }

+int

+gf_cli_ganesha_cbk(struct rpc_req *req, struct iovec *iov, int count,

+                   void *myframe)

+{

+    gf_cli_rsp rsp = {

+        0,

+    };

+    int ret = -1;

+    dict_t *dict = NULL;

+

+    GF_ASSERT(myframe);

+

+    if (-1 == req->rpc_status) {

+        goto out;

+    }

+

+    ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);

+    if (ret < 0) {

+        gf_log(((call_frame_t *)myframe)->this->name, GF_LOG_ERROR,

+               "Failed to decode xdr response");

+        goto out;

+    }

+

+    gf_log("cli", GF_LOG_DEBUG, "Received resp to ganesha");

+

+    dict = dict_new();

+

+    if (!dict) {

+        ret = -1;

+        goto out;

+    }

+

+    ret = dict_unserialize(rsp.dict.dict_val, rsp.dict.dict_len, &dict);

+    if (ret)

+        goto out;

+

+    if (rsp.op_ret) {

+        if (strcmp(rsp.op_errstr, ""))

+            cli_err("nfs-ganesha: failed: %s", rsp.op_errstr);

+        else

+            cli_err("nfs-ganesha: failed");

+    }

+

+    else {

+        cli_out("nfs-ganesha : success ");

+    }

+

+    ret = rsp.op_ret;

+

+out:

+    if (dict)

+        dict_unref(dict);

+    cli_cmd_broadcast_response(ret);

+    return ret;

+}

+

 char *

 is_server_debug_xlator(void *myframe)

 {

@@ -4880,6 +4936,31 @@ out:

 }

 int32_t

+gf_cli_ganesha(call_frame_t *frame, xlator_t *this, void *data)

+{

+    gf_cli_req req = {{

+        0,

+    }};

+    int ret = 0;

+    dict_t *dict = NULL;

+

+    if (!frame || !this || !data) {

+        ret = -1;

+        goto out;

+    }

+

+    dict = data;

+

+    ret = cli_to_glusterd(&req, frame, gf_cli_ganesha_cbk,

+                          (xdrproc_t)xdr_gf_cli_req, dict, GLUSTER_CLI_GANESHA,

+                          this, cli_rpc_prog, NULL);

+out:

+    gf_log("cli", GF_LOG_DEBUG, "Returning %d", ret);

+

+    return ret;

+}

+

+int32_t

 gf_cli_set_volume(call_frame_t *frame, xlator_t *this, void *data)

 {

     gf_cli_req req = {{

@@ -12214,6 +12295,7 @@ struct rpc_clnt_procedure gluster_cli_actors[GLUSTER_CLI_MAXVALUE] = {

     [GLUSTER_CLI_SYS_EXEC] = {"SYS_EXEC", gf_cli_sys_exec},

     [GLUSTER_CLI_SNAP] = {"SNAP", gf_cli_snapshot},

     [GLUSTER_CLI_BARRIER_VOLUME] = {"BARRIER VOLUME", gf_cli_barrier_volume},

+    [GLUSTER_CLI_GANESHA] = {"GANESHA", gf_cli_ganesha},

     [GLUSTER_CLI_GET_VOL_OPT] = {"GET_VOL_OPT", gf_cli_get_vol_opt},

     [GLUSTER_CLI_BITROT] = {"BITROT", gf_cli_bitrot},

     [GLUSTER_CLI_ATTACH_TIER] = {"ATTACH_TIER", gf_cli_attach_tier},

diff --git a/cli/src/cli.h b/cli/src/cli.h

index b79a0a2..37e4d9d 100644

--- a/cli/src/cli.h

+++ b/cli/src/cli.h

@@ -282,6 +282,10 @@ cli_cmd_volume_set_parse(struct cli_state *state, const char **words,

                          int wordcount, dict_t **options, char **op_errstr);

 int32_t

+cli_cmd_ganesha_parse(struct cli_state *state, const char **words,

+                      int wordcount, dict_t **options, char **op_errstr);

+

+int32_t

 cli_cmd_get_state_parse(struct cli_state *state, const char **words,

                         int wordcount, dict_t **options, char **op_errstr);

diff --git a/xlators/mgmt/glusterd/src/Makefile.am b/xlators/mgmt/glusterd/src/Makefile.am

index c8dd8e3..5fe5156 100644

--- a/xlators/mgmt/glusterd/src/Makefile.am

+++ b/xlators/mgmt/glusterd/src/Makefile.am

@@ -10,7 +10,7 @@ glusterd_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS) $(LIB_DL)

 glusterd_la_SOURCES = glusterd.c glusterd-handler.c glusterd-sm.c \

 	glusterd-op-sm.c glusterd-utils.c glusterd-rpc-ops.c \

 	glusterd-store.c glusterd-handshake.c glusterd-pmap.c \

-	glusterd-volgen.c glusterd-rebalance.c \

+	glusterd-volgen.c glusterd-rebalance.c glusterd-ganesha.c \

 	glusterd-quota.c glusterd-bitrot.c glusterd-geo-rep.c \

 	glusterd-replace-brick.c glusterd-log-ops.c glusterd-tier.c \

 	glusterd-volume-ops.c glusterd-brick-ops.c glusterd-mountbroker.c \

@@ -52,6 +52,8 @@ AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \

 	-I$(CONTRIBDIR)/mount -I$(CONTRIBDIR)/userspace-rcu \

 	-DSBIN_DIR=\"$(sbindir)\" -DDATADIR=\"$(localstatedir)\" \

 	-DGSYNCD_PREFIX=\"$(GLUSTERFS_LIBEXECDIR)\" \

+	-DCONFDIR=\"$(localstatedir)/run/gluster/shared_storage/nfs-ganesha\" \

+	-DGANESHA_PREFIX=\"$(libexecdir)/ganesha\" \

 	-DSYNCDAEMON_COMPILE=$(SYNCDAEMON_COMPILE)

diff --git a/xlators/mgmt/glusterd/src/glusterd-errno.h b/xlators/mgmt/glusterd/src/glusterd-errno.h

index 7e1575b..c74070e 100644

--- a/xlators/mgmt/glusterd/src/glusterd-errno.h

+++ b/xlators/mgmt/glusterd/src/glusterd-errno.h

@@ -27,7 +27,7 @@ enum glusterd_op_errno {

     EG_ISSNAP = 30813,    /* Volume is a snap volume           */

     EG_GEOREPRUN = 30814, /* Geo-Replication is running        */

     EG_NOTTHINP = 30815,  /* Bricks are not thinly provisioned */

-    EG_NOGANESHA = 30816, /* obsolete ganesha is not enabled   */

+    EG_NOGANESHA = 30816, /* Global ganesha is not enabled   */

 };

 #endif

diff --git a/xlators/mgmt/glusterd/src/glusterd-ganesha.c b/xlators/mgmt/glusterd/src/glusterd-ganesha.c

new file mode 100644

index 0000000..fac16e6

--- /dev/null

+++ b/xlators/mgmt/glusterd/src/glusterd-ganesha.c

@@ -0,0 +1,915 @@

+/*

+   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>

+   This file is part of GlusterFS.

+

+   This file is licensed to you under your choice of the GNU Lesser

+   General Public License, version 3 or any later version (LGPLv3 or

+   later), or the GNU General Public License, version 2 (GPLv2), in all

+   cases as published by the Free Software Foundation.

+*/

+

+#include <glusterfs/common-utils.h>

+#include "glusterd.h"

+#include "glusterd-op-sm.h"

+#include "glusterd-store.h"

+#include "glusterd-utils.h"

+#include "glusterd-nfs-svc.h"

+#include "glusterd-volgen.h"

+#include "glusterd-messages.h"

+#include <glusterfs/syscall.h>

+

+#include <ctype.h>

+

+int

+start_ganesha(char **op_errstr);

+

+typedef struct service_command {

+    char *binary;

+    char *service;

+    int (*action)(struct service_command *, char *);

+} service_command;

+

+/* parsing_ganesha_ha_conf will allocate the returned string

+ * to be freed (GF_FREE) by the caller

+ * return NULL if error or not found */

+static char *

+parsing_ganesha_ha_conf(const char *key)

+{

+#define MAX_LINE 1024

+    char scratch[MAX_LINE * 2] = {

+        0,

+    };

+    char *value = NULL, *pointer = NULL, *end_pointer = NULL;

+    FILE *fp;

+

+    fp = fopen(GANESHA_HA_CONF, "r");

+    if (fp == NULL) {

+        gf_msg(THIS->name, GF_LOG_ERROR, errno, GD_MSG_FILE_OP_FAILED,

+               "couldn't open the file %s", GANESHA_HA_CONF);

+        goto end_ret;

+    }

+    while ((pointer = fgets(scratch, MAX_LINE, fp)) != NULL) {

+        /* Read config file until we get matching "^[[:space:]]*key" */

+        if (*pointer == '#') {

+            continue;

+        }

+        while (isblank(*pointer)) {

+            pointer++;

+        }

+        if (strncmp(pointer, key, strlen(key))) {

+            continue;

+        }

+        pointer += strlen(key);

+        /* key found : if we fail to parse, we'll return an error

+         * rather than trying next one

+         * - supposition : conf file is bash compatible : no space

+         *   around the '=' */

+        if (*pointer != '=') {

+            gf_msg(THIS->name, GF_LOG_ERROR, errno,

+                   GD_MSG_GET_CONFIG_INFO_FAILED, "Parsing %s failed at key %s",

+                   GANESHA_HA_CONF, key);

+            goto end_close;

+        }

+        pointer++; /* jump the '=' */

+

+        if (*pointer == '"' || *pointer == '\'') {

+            /* dont get the quote */

+            pointer++;

+        }

+        end_pointer = pointer;

+        /* stop at the next closing quote or  blank/newline */

+        do {

+            end_pointer++;

+        } while (!(*end_pointer == '\'' || *end_pointer == '"' ||

+                   isspace(*end_pointer) || *end_pointer == '\0'));

+        *end_pointer = '\0';

+

+        /* got it. copy it and return */

+        value = gf_strdup(pointer);

+        break;

+    }

+

+end_close:

+    fclose(fp);

+end_ret:

+    return value;

+}

+

+static int

+sc_systemctl_action(struct service_command *sc, char *command)

+{

+    runner_t runner = {

+        0,

+    };

+

+    runinit(&runner);

+    runner_add_args(&runner, sc->binary, command, sc->service, NULL);

+    return runner_run(&runner);

+}

+

+static int

+sc_service_action(struct service_command *sc, char *command)

+{

+    runner_t runner = {

+        0,

+    };

+

+    runinit(&runner);

+    runner_add_args(&runner, sc->binary, sc->service, command, NULL);

+    return runner_run(&runner);

+}

+

+static int

+manage_service(char *action)

+{

+    struct stat stbuf = {

+        0,

+    };

+    int i = 0;

+    int ret = 0;

+    struct service_command sc_list[] = {{.binary = "/usr/bin/systemctl",

+                                         .service = "nfs-ganesha",

+                                         .action = sc_systemctl_action},

+                                        {.binary = "/sbin/invoke-rc.d",

+                                         .service = "nfs-ganesha",

+                                         .action = sc_service_action},

+                                        {.binary = "/sbin/service",

+                                         .service = "nfs-ganesha",

+                                         .action = sc_service_action},

+                                        {.binary = NULL}};

+

+    while (sc_list[i].binary != NULL) {

+        ret = sys_stat(sc_list[i].binary, &stbuf);

+        if (ret == 0) {

+            gf_msg_debug(THIS->name, 0, "%s found.", sc_list[i].binary);

+            if (strcmp(sc_list[i].binary, "/usr/bin/systemctl") == 0)

+                ret = sc_systemctl_action(&sc_list[i], action);

+            else

+                ret = sc_service_action(&sc_list[i], action);

+

+            return ret;

+        }

+        i++;

+    }

+    gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_UNRECOGNIZED_SVC_MNGR,

+           "Could not %s NFS-Ganesha.Service manager for distro"

+           " not recognized.",

+           action);

+    return ret;

+}

+

+/*

+ * Check if the cluster is a ganesha cluster or not *

+ */

+gf_boolean_t

+glusterd_is_ganesha_cluster()

+{

+    int ret = -1;

+    glusterd_conf_t *priv = NULL;

+    xlator_t *this = NULL;

+    gf_boolean_t ret_bool = _gf_false;

+

+    this = THIS;

+    GF_VALIDATE_OR_GOTO("ganesha", this, out);

+    priv = this->private;

+    GF_VALIDATE_OR_GOTO(this->name, priv, out);

+

+    ret = dict_get_str_boolean(priv->opts, GLUSTERD_STORE_KEY_GANESHA_GLOBAL,

+                               _gf_false);

+    if (ret == _gf_true) {

+        ret_bool = _gf_true;

+        gf_msg_debug(this->name, 0, "nfs-ganesha is enabled for the cluster");

+    } else

+        gf_msg_debug(this->name, 0, "nfs-ganesha is disabled for the cluster");

+

+out:

+    return ret_bool;

+}

+

+/* Check if ganesha.enable is set to 'on', that checks if

+ * a  particular volume is exported via NFS-Ganesha */

+gf_boolean_t

+glusterd_check_ganesha_export(glusterd_volinfo_t *volinfo)

+{

+    char *value = NULL;

+    gf_boolean_t is_exported = _gf_false;

+    int ret = 0;

+

+    ret = glusterd_volinfo_get(volinfo, "ganesha.enable", &value);

+    if ((ret == 0) && value) {

+        if (strcmp(value, "on") == 0) {

+            gf_msg_debug(THIS->name, 0,

+                         "ganesha.enable set"

+                         " to %s",

+                         value);

+            is_exported = _gf_true;

+        }

+    }

+    return is_exported;

+}

+

+/* *

+ * The below function is called as part of commit phase for volume set option

+ * "ganesha.enable". If the value is "on", it creates export configuration file

+ * and then export the volume via dbus command. Incase of "off", the volume

+ * will be already unexported during stage phase, so it will remove the conf

+ * file from shared storage

+ */

+int

+glusterd_check_ganesha_cmd(char *key, char *value, char **errstr, dict_t *dict)

+{

+    int ret = 0;

+    char *volname = NULL;

+

+    GF_ASSERT(key);

+    GF_ASSERT(value);

+    GF_ASSERT(dict);

+

+    if ((strcmp(key, "ganesha.enable") == 0)) {

+        if ((strcmp(value, "on")) && (strcmp(value, "off"))) {

+            gf_asprintf(errstr,

+                        "Invalid value"

+                        " for volume set command. Use on/off only.");

+            ret = -1;

+            goto out;

+        }

+        if (strcmp(value, "on") == 0) {

+            ret = glusterd_handle_ganesha_op(dict, errstr, key, value);

+

+        } else if (is_origin_glusterd(dict)) {

+            ret = dict_get_str(dict, "volname", &volname);

+            if (ret) {

+                gf_msg("glusterd-ganesha", GF_LOG_ERROR, errno,

+                       GD_MSG_DICT_GET_FAILED, "Unable to get volume name");

+                goto out;

+            }

+            ret = manage_export_config(volname, "off", errstr);

+        }

+    }

+out:

+    if (ret) {

+        gf_msg("glusterd-ganesha", GF_LOG_ERROR, 0,

+               GD_MSG_NFS_GNS_OP_HANDLE_FAIL,

+               "Handling NFS-Ganesha"

+               " op failed.");

+    }

+    return ret;

+}

+

+int

+glusterd_op_stage_set_ganesha(dict_t *dict, char **op_errstr)

+{

+    int ret = -1;

+    int value = -1;

+    gf_boolean_t option = _gf_false;

+    char *str = NULL;

+    glusterd_conf_t *priv = NULL;

+    xlator_t *this = NULL;

+

+    GF_ASSERT(dict);

+    this = THIS;

+    GF_ASSERT(this);

+    priv = this->private;

+    GF_ASSERT(priv);

+

+    value = dict_get_str_boolean(dict, "value", _gf_false);

+    if (value == -1) {

+        gf_msg(this->name, GF_LOG_ERROR, errno, GD_MSG_DICT_GET_FAILED,

+               "value not present.");