glusterd: bring in feature to use syncop for mgmt ops

* new sycnop routines added to mgmt program
* one should not use 'glusterd_op_begin()', instead can use the
  synctask framework, 'glusterd_op_begin_synctask()'
* currently using for below operations:
  'volume start', 'volume rebalance', 'volume quota',
  'volume replace-brick' and 'volume add-brick'

Change-Id: I0bee76d06790d5c5bb5db15d443b44af0e21f1c0
BUG: 762935
Signed-off-by: Amar Tumballi <amar@gluster.com>
Reviewed-on: http://review.gluster.com/479
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Anand Avati <avati@redhat.com>

1 files changed, 167 insertions, 0 deletions

diff --git a/xlators/mgmt/glusterd/src/glusterd-handler.c b/xlators/mgmt/glusterd/src/glusterd-handler.c
index 86bc0d7b1c6..0ee3bfd2440 100644
--- a/xlators/mgmt/glusterd/src/glusterd-handler.c
+++ b/xlators/mgmt/glusterd/src/glusterd-handler.c
@@ -57,6 +57,9 @@
 #include "defaults.c"
 #include "common-utils.h"
 
+#include "globals.h"
+#include "glusterd-syncop.h"
+
 static int
 glusterd_handle_friend_req (rpcsvc_request_t *req, uuid_t  uuid,
                             char *hostname, int port,
@@ -944,6 +947,140 @@ out:
 
         glusterd_friend_sm ();
         glusterd_op_sm ();
+
+        return ret;
+}
+
+int
+gd_sync_task_begin (void *data)
+{
+        int                  ret      = -1;
+        dict_t              *dict     = NULL;
+        dict_t              *rsp_dict = NULL;
+        glusterd_peerinfo_t *peerinfo = NULL;
+        glusterd_conf_t     *conf     = NULL;
+        uuid_t               tmp_uuid = {0,};
+        char                *errstr   = NULL;
+        glusterd_op_t        op       = 0;
+        int32_t              tmp_op   = 0;
+        gf_boolean_t         local_locked = _gf_false;
+
+        conf = THIS->private;
+
+        dict = data;
+
+        ret = dict_get_int32 (dict, "operation", &tmp_op);
+        if (ret)
+                goto out;
+
+        op = tmp_op;
+
+        ret = -1;
+        rsp_dict = dict_new ();
+        if (!rsp_dict)
+                goto out;
+
+        /*  Lock everything */
+        ret = glusterd_lock (conf->uuid);
+        if (ret)
+                goto out;
+        /* successful lock in local node */
+        local_locked = _gf_true;
+
+        list_for_each_entry (peerinfo, &conf->peers, uuid_list) {
+                ret = gd_syncop_mgmt_lock (peerinfo->rpc,
+                                           conf->uuid, tmp_uuid);
+                if (ret)
+                        goto out;
+                /* TODO: Only on lock successful nodes it should unlock */
+        }
+
+        /* stage op */
+        ret = glusterd_op_stage_validate (op, dict, &errstr, rsp_dict);
+        if (ret)
+                goto out;
+
+        list_for_each_entry (peerinfo, &conf->peers, uuid_list) {
+                ret = gd_syncop_mgmt_stage_op (peerinfo->rpc,
+                                               conf->uuid, tmp_uuid,
+                                               op, dict, &rsp_dict, &errstr);
+                if (ret) {
+                        if (errstr)
+                                ret = dict_set_dynstr (dict, "error", errstr);
+
+                        ret = -1;
+                        goto out;
+                }
+        }
+
+        /* commit op */
+        ret = glusterd_op_commit_perform (op, dict, &errstr, rsp_dict);
+        if (ret)
+                goto out;
+
+        list_for_each_entry (peerinfo, &conf->peers, uuid_list) {
+                ret = gd_syncop_mgmt_commit_op (peerinfo->rpc,
+                                                conf->uuid, tmp_uuid,
+                                                op, dict, &rsp_dict, &errstr);
+                if (ret) {
+                        if (errstr)
+                                ret = dict_set_dynstr (dict, "error", errstr);
+
+                        ret = -1;
+                        goto out;
+                }
+        }
+
+        ret = 0;
+out:
+        if (local_locked) {
+                /* unlock everything as we help successful local lock */
+                list_for_each_entry (peerinfo, &conf->peers, uuid_list) {
+                        /* No need to check the error code, as it is possible
+                           that if 'lock' on few nodes failed, it would come
+                           here, and unlock would fail on nodes where lock
+                           never was sent */
+                        gd_syncop_mgmt_unlock (peerinfo->rpc,
+                                               conf->uuid, tmp_uuid);
+                }
+
+                /* Local node should be the one to be locked first,
+                   unlocked last to prevent races */
+                glusterd_unlock (conf->uuid);
+        }
+
+        if (rsp_dict)
+                dict_unref (rsp_dict);
+
+        return ret;
+}
+
+int
+gd_sync_task_completion (int op_ret, call_frame_t *sync_frame, void *data)
+{
+        int               ret    = 0;
+        dict_t           *dict   = NULL;
+        rpcsvc_request_t *req    = NULL;
+        int32_t           tmp_op = 0;
+        glusterd_op_t     op     = 0;
+
+        dict = data;
+
+        req = sync_frame->local;
+        sync_frame->local = NULL;
+
+        ret = dict_get_int32 (dict, "operation", &tmp_op);
+        if (ret)
+                goto out;
+        op = tmp_op;
+
+        ret = glusterd_op_send_cli_response (op, op_ret, 0, req, NULL,
+                                             "operation failed");
+
+out:
+        if (dict)
+                dict_unref (dict);
+
         return ret;
 }
 
@@ -958,6 +1095,36 @@ glusterd_op_begin (rpcsvc_request_t *req, glusterd_op_t op, void *ctx)
 }
 
 
+int32_t
+glusterd_op_begin_synctask (rpcsvc_request_t *req, glusterd_op_t op,
+                            void *dict)
+{
+        int              ret = 0;
+        call_frame_t    *dummy_frame = NULL;
+        glusterfs_ctx_t *ctx = NULL;
+
+        dummy_frame = create_frame (THIS, THIS->ctx->pool);
+        if (!dummy_frame)
+                goto out;
+
+        dummy_frame->local = req;
+
+        ret = dict_set_int32 (dict, "operation", op);
+        if (ret) {
+                gf_log (THIS->name, GF_LOG_ERROR,
+                        "dict set failed for setting operations");
+                goto out;
+        }
+
+        ctx = glusterfs_ctx_get ();
+
+        ret = synctask_new (ctx->env, gd_sync_task_begin,
+                            gd_sync_task_completion,
+                            dummy_frame, dict);
+out:
+        return ret;
+}
+
 
 int
 glusterd_handle_reset_volume (rpcsvc_request_t *req)