glusterd: remove replace brick with data migration support form cli/glusterd

Replace-brick operation with data migration support have been
deprecated from gluster.

With this fix replace brick command will support only one commad

gluster volume replace-brick <VOLNAME> <SOURCE-BRICK> <NEW-BRICK> {commit force}

Change-Id: Ib81d49e5d8e7eaa4ccb5830cfec2bc081191b43b
BUG: 1094119
Signed-off-by: Gaurav Kumar Garg <ggarg@redhat.com>
Reviewed-on: http://review.gluster.org/10101
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Kaushal M <kaushal@redhat.com>

22 files changed, 168 insertions, 2218 deletions

diff --git a/cli/src/cli-cmd-parser.c b/cli/src/cli-cmd-parser.c
index 99ef7014d2d..310c5f06033 100644
--- a/cli/src/cli-cmd-parser.c
+++ b/cli/src/cli-cmd-parser.c
@@ -1891,44 +1891,36 @@ out:
 
 int32_t
 cli_cmd_volume_replace_brick_parse (const char **words, int wordcount,
-                                   dict_t **options)
+                                    dict_t **options)
 {
-        dict_t  *dict = NULL;
-        char    *volname = NULL;
-        int     ret = -1;
-        int     op_index = 0;
-        char    *delimiter = NULL;
-        gf1_cli_replace_op replace_op = GF_REPLACE_OP_NONE;
-        char    *opwords[] = { "start", "commit", "pause", "abort", "status",
-                                NULL };
-        char    *w = NULL;
-        gf_boolean_t is_force = _gf_false;
+        int                   ret        = -1;
+        char                 *volname    = NULL;
+        char                 *delimiter  = NULL;
+        dict_t               *dict       = NULL;
 
         GF_ASSERT (words);
         GF_ASSERT (options);
 
-        dict = dict_new ();
-
-        if (!dict)
+        if (wordcount != 7) {
+                ret = -1;
                 goto out;
+        }
 
-        if (wordcount < 3)
+        dict = dict_new ();
+
+        if (!dict) {
+                gf_log ("cli", GF_LOG_ERROR, "Failed to allocate dictionary");
                 goto out;
+        }
 
         volname = (char *)words[2];
 
         GF_ASSERT (volname);
 
         ret = dict_set_str (dict, "volname", volname);
-
         if (ret)
                 goto out;
 
-        if (wordcount < 4) {
-                ret = -1;
-                goto out;
-        }
-
         if (validate_brick_name ((char *)words[3])) {
                 cli_err ("wrong brick type: %s, use "
                          "<HOSTNAME>:<export-dir-abs-path>", words[3]);
@@ -1940,16 +1932,11 @@ cli_cmd_volume_replace_brick_parse (const char **words, int wordcount,
                 if (ret)
                         goto out;
         }
-        ret = dict_set_str (dict, "src-brick", (char *)words[3]);
 
+        ret = dict_set_str (dict, "src-brick", (char *)words[3]);
         if (ret)
                 goto out;
 
-        if (wordcount < 5) {
-                ret = -1;
-                goto out;
-        }
-
         if (validate_brick_name ((char *)words[4])) {
                 cli_err ("wrong brick type: %s, use "
                          "<HOSTNAME>:<export-dir-abs-path>", words[4]);
@@ -1962,69 +1949,20 @@ cli_cmd_volume_replace_brick_parse (const char **words, int wordcount,
                         goto out;
         }
 
-
         ret = dict_set_str (dict, "dst-brick", (char *)words[4]);
-
         if (ret)
                 goto out;
 
-        op_index = 5;
-        if ((wordcount < (op_index + 1))) {
-                ret = -1;
-                goto out;
-        }
-
-        w = str_getunamb (words[op_index], opwords);
-
-        if (!w) {
-        } else if (!strcmp ("start", w)) {
-                replace_op = GF_REPLACE_OP_START;
-        } else if (!strcmp ("commit", w)) {
-                replace_op = GF_REPLACE_OP_COMMIT;
-        } else if (!strcmp ("pause", w)) {
-                replace_op = GF_REPLACE_OP_PAUSE;
-        } else if (!strcmp ("abort", w)) {
-                replace_op = GF_REPLACE_OP_ABORT;
-        } else if (!strcmp ("status", w)) {
-                replace_op = GF_REPLACE_OP_STATUS;
-        } else
-                GF_ASSERT (!"opword mismatch");
-
         /* commit force option */
-
-        op_index = 6;
-
-        if (wordcount > (op_index + 1)) {
+        if (strcmp ("commit", words[5]) || strcmp ("force", words[6])) {
+                cli_err ("Invalid option '%s' '%s' for replace-brick. Please "
+                         "enter valid replace-brick command", words[5],
+                         words[6]);
                 ret = -1;
                 goto out;
         }
 
-        if (wordcount == (op_index + 1)) {
-                if ((replace_op != GF_REPLACE_OP_COMMIT) &&
-                    (replace_op != GF_REPLACE_OP_START)) {
-                        ret = -1;
-                        goto out;
-                }
-                if (!strcmp ("force", words[op_index])) {
-                        if (replace_op == GF_REPLACE_OP_COMMIT)
-                                replace_op = GF_REPLACE_OP_COMMIT_FORCE;
-
-                        else if (replace_op == GF_REPLACE_OP_START)
-                                is_force = _gf_true;
-                }
-        }
-
-        if (replace_op == GF_REPLACE_OP_NONE) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_set_int32 (dict, "operation", (int32_t) replace_op);
-
-        if (ret)
-                goto out;
-
-        ret = dict_set_int32 (dict, "force", is_force);
+        ret = dict_set_str (dict, "operation", "GF_REPLACE_OP_COMMIT_FORCE");
         if (ret)
                 goto out;
 
diff --git a/cli/src/cli-cmd-volume.c b/cli/src/cli-cmd-volume.c
index 0dfb647b92c..d121ac94739 100644
--- a/cli/src/cli-cmd-volume.c
+++ b/cli/src/cli-cmd-volume.c
@@ -1655,18 +1655,13 @@ cli_cmd_volume_replace_brick_cbk (struct cli_state *state,
                                   const char **words,
                                   int wordcount)
 {
-        int                     ret = -1;
-        rpc_clnt_procedure_t    *proc = NULL;
-        call_frame_t            *frame = NULL;
+        int                      ret          = -1;
+        rpc_clnt_procedure_t    *proc         = NULL;
+        call_frame_t            *frame        = NULL;
         dict_t                  *options = NULL;
-        int                     sent = 0;
-        int                     parse_error = 0;
+        int                      sent = 0;
+        int                      parse_error = 0;
         cli_local_t             *local = NULL;
-        int                     replace_op = 0;
-        char                    *q = "All replace-brick commands except "
-                                     "commit force are deprecated. "
-                                     "Do you want to continue?";
-        gf_answer_t             answer = GF_ANSWER_NO;
 
 #ifdef GF_SOLARIS_HOST_OS
         cli_out ("Command not supported on Solaris");
@@ -1686,24 +1681,6 @@ cli_cmd_volume_replace_brick_cbk (struct cli_state *state,
                 goto out;
         }
 
-        ret = dict_get_int32 (options, "operation", &replace_op);
-        if (replace_op != GF_REPLACE_OP_COMMIT_FORCE) {
-                answer = cli_cmd_get_confirmation (state, q);
-                if (GF_ANSWER_NO == answer) {
-                        ret = 0;
-                        goto out;
-                }
-        }
-
-        if (state->mode & GLUSTER_MODE_WIGNORE) {
-                ret = dict_set_int32 (options, "force", _gf_true);
-                if (ret) {
-                        gf_log ("cli", GF_LOG_ERROR, "Failed to set force"
-                                "option");
-                        goto out;
-                }
-        }
-
         CLI_LOCAL_INIT (local, words, frame, options);
 
         if (proc->fn) {
@@ -2604,7 +2581,8 @@ struct cli_cmd volume_cmds[] = {
           cli_cmd_volume_defrag_cbk,
           "rebalance operations"},
 
-        { "volume replace-brick <VOLNAME> <BRICK> <NEW-BRICK> {start [force]|pause|abort|status|commit [force]}",
+        { "volume replace-brick <VOLNAME> <SOURCE-BRICK> <NEW-BRICK> "
+          "{commit force}",
           cli_cmd_volume_replace_brick_cbk,
           "replace-brick operations"},
 
diff --git a/cli/src/cli-rpc-ops.c b/cli/src/cli-rpc-ops.c
index 5504515fd5e..2b84aa6b060 100644
--- a/cli/src/cli-rpc-ops.c
+++ b/cli/src/cli-rpc-ops.c
@@ -2316,8 +2316,6 @@ out:
         return ret;
 }
 
-
-
 int
 gf_cli_replace_brick_cbk (struct rpc_req *req, struct iovec *iov,
                              int count, void *myframe)
@@ -2330,11 +2328,11 @@ gf_cli_replace_brick_cbk (struct rpc_req *req, struct iovec *iov,
         char                            *src_brick        = NULL;
         char                            *dst_brick        = NULL;
         char                            *status_reply     = NULL;
-        gf1_cli_replace_op               replace_op       = 0;
         char                            *rb_operation_str = NULL;
         dict_t                          *rsp_dict         = NULL;
         char                             msg[1024]        = {0,};
         char                            *task_id_str      = NULL;
+        char                            *replace_op       = 0;
 
         if (-1 == req->rpc_status) {
                 goto out;
@@ -2353,9 +2351,9 @@ gf_cli_replace_brick_cbk (struct rpc_req *req, struct iovec *iov,
         GF_ASSERT (local);
         dict = local->dict;
 
-        ret = dict_get_int32 (dict, "operation", (int32_t *)&replace_op);
+        ret = dict_get_str (dict, "operation", &replace_op);
         if (ret) {
-                gf_log ("", GF_LOG_DEBUG,
+                gf_log (frame->this->name, GF_LOG_ERROR,
                         "dict_get on operation failed");
                 goto out;
         }
@@ -2368,101 +2366,23 @@ gf_cli_replace_brick_cbk (struct rpc_req *req, struct iovec *iov,
                                 rsp.dict.dict_len,
                                 &rsp_dict);
                 if (ret < 0) {
-                        gf_log ("glusterd", GF_LOG_ERROR,
-                                        "failed to "
-                                        "unserialize rsp buffer to dictionary");
+                        gf_log (frame->this->name, GF_LOG_ERROR, "failed to "
+                                "unserialize rsp buffer to dictionary");
                         goto out;
                 }
         }
 
-        switch (replace_op) {
-        case GF_REPLACE_OP_START:
-                if (rsp.op_ret) {
-                        rb_operation_str = gf_strdup ("replace-brick failed to"
-                                                      " start");
-                } else {
-                        ret = dict_get_str (rsp_dict, GF_REPLACE_BRICK_TID_KEY,
-                                            &task_id_str);
-                        if (ret) {
-                                gf_log ("cli", GF_LOG_ERROR, "Failed to get "
-                                        "\"replace-brick-id\" from dict");
-                                goto out;
-                        }
-                        ret = gf_asprintf (&rb_operation_str,
-                                           "replace-brick started successfully"
-                                           "\nID: %s", task_id_str);
-                        if (ret < 0)
-                                goto out;
-                }
-                break;
-
-        case GF_REPLACE_OP_STATUS:
-
-                if (rsp.op_ret || ret) {
-                        rb_operation_str = gf_strdup ("replace-brick status "
-                                                      "unknown");
-                } else {
-                        ret = dict_get_str (rsp_dict, "status-reply",
-                                            &status_reply);
-                        if (ret) {
-                                gf_log (frame->this->name, GF_LOG_ERROR, "failed to"
-                                        "get status");
-                                goto out;
-                        }
-
-                        rb_operation_str = gf_strdup (status_reply);
-                }
-
-                break;
-
-        case GF_REPLACE_OP_PAUSE:
-                if (rsp.op_ret)
-                        rb_operation_str = gf_strdup ("replace-brick pause "
-                                                      "failed");
-                else
-                        rb_operation_str = gf_strdup ("replace-brick paused "
-                                                      "successfully");
-                break;
-
-        case GF_REPLACE_OP_ABORT:
-                if (rsp.op_ret)
-                        rb_operation_str = gf_strdup ("replace-brick abort "
-                                                      "failed");
-                else
-                        rb_operation_str = gf_strdup ("replace-brick aborted "
-                                                      "successfully");
-                break;
-
-        case GF_REPLACE_OP_COMMIT:
-        case GF_REPLACE_OP_COMMIT_FORCE:
-                ret = dict_get_str (dict, "src-brick", &src_brick);
-                if (ret) {
-                        gf_log ("", GF_LOG_DEBUG,
-                                "dict_get on src-brick failed");
-                        goto out;
-                }
-
-                ret = dict_get_str (dict, "dst-brick", &dst_brick);
-                if (ret) {
-                        gf_log ("", GF_LOG_DEBUG,
-                                "dict_get on dst-brick failed");
-                        goto out;
-                }
-
+        if (!strcmp(replace_op, "GF_REPLACE_OP_COMMIT_FORCE")) {
 
                 if (rsp.op_ret || ret)
                         rb_operation_str = gf_strdup ("replace-brick commit "
-                                                      "failed");
+                                                      "force operation failed");
                 else
                         rb_operation_str = gf_strdup ("replace-brick commit "
+                                                      "force operation "
                                                       "successful");
-
-                break;
-
-        default:
-                gf_log ("", GF_LOG_DEBUG,
-                        "Unknown operation");
-                break;
+        } else {
+                gf_log (frame->this->name, GF_LOG_DEBUG, "Unknown operation");
         }
 
         if (rsp.op_ret && (strcmp (rsp.op_errstr, ""))) {
@@ -6928,35 +6848,7 @@ cli_print_volume_status_tasks (dict_t *dict)
 
                 snprintf (task, sizeof (task), "task%d", i);
 
-                /*
-                   Replace brick only has two states - In progress and Complete
-                   Ref: xlators/mgmt/glusterd/src/glusterd-replace-brick.c
-                */
-
-                if (!strcmp (op, "Replace brick")) {
-                        if (status)
-                                status = GF_DEFRAG_STATUS_COMPLETE;
-                        else
-                                status = GF_DEFRAG_STATUS_STARTED;
-
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "%s.src-brick", task);
-                        ret = dict_get_str (dict, key, &src_brick);
-                        if (ret)
-                                goto out;
-
-                        cli_out ("%-20s : %-20s", "Source Brick", src_brick);
-
-                        memset (key, 0, sizeof (key));
-                        snprintf (key, sizeof (key), "%s.dst-brick", task);
-                        ret = dict_get_str (dict, key, &dest_brick);
-                        if (ret)
-                                goto out;
-
-                        cli_out ("%-20s : %-20s", "Destination Brick",
-                                 dest_brick);
-
-                } else if (!strcmp (op, "Remove brick")) {
+                if (!strcmp (op, "Remove brick")) {
                         memset (key, 0, sizeof (key));
                         snprintf (key, sizeof (key), "%s.count", task);
                         ret = dict_get_int32 (dict, key, &count);
diff --git a/cli/src/cli-xml-output.c b/cli/src/cli-xml-output.c
index d7322d5bb0d..f9013ed2726 100644
--- a/cli/src/cli-xml-output.c
+++ b/cli/src/cli-xml-output.c
@@ -1480,46 +1480,6 @@ out:
 }
 
 int
-cli_xml_output_replace_brick_task_params (xmlTextWriterPtr writer, dict_t *dict,
-                                          char *prefix)
-{
-
-        int             ret = -1;
-        char            key[1024] = {0,};
-        char            *brick = NULL;
-
-        /* <params> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"params");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        snprintf (key, sizeof (key), "%s.src-brick", prefix);
-        ret = dict_get_str (dict, key, &brick);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"srcBrick",
-                                               "%s", brick);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-
-        memset (key, 0, sizeof (key));
-        snprintf (key, sizeof (key), "%s.dst-brick", prefix);
-        ret = dict_get_str (dict, key, &brick);
-        if (ret)
-                goto out;
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"dstBrick",
-                                               "%s", brick);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-
-        /* </param> */
-        ret = xmlTextWriterEndElement (writer);
-
-out:
-        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
-}
-
-int
 cli_xml_output_vol_status_tasks (cli_local_t *local, dict_t *dict) {
         int                     ret = -1;
         char                    *task_type = NULL;
@@ -1573,14 +1533,6 @@ cli_xml_output_vol_status_tasks (cli_local_t *local, dict_t *dict) {
                                                        "%d", status);
                 XML_RET_CHECK_AND_GOTO (ret, out);
 
-                if (!strcmp (task_type, "Replace brick")) {
-                    if (status) {
-                        status = GF_DEFRAG_STATUS_COMPLETE;
-                    } else {
-                        status = GF_DEFRAG_STATUS_STARTED;
-                    }
-                }
-
                 ret = xmlTextWriterWriteFormatElement (local->writer,
                                                        (xmlChar *)"statusStr",
                                                        "%s",
@@ -1590,12 +1542,7 @@ cli_xml_output_vol_status_tasks (cli_local_t *local, dict_t *dict) {
 
                 memset (key, 0, sizeof (key));
                 snprintf (key, sizeof (key), "task%d", i);
-                if (!strcmp (task_type, "Replace brick")) {
-                        ret = cli_xml_output_replace_brick_task_params
-                                (local->writer, dict, key);
-                        if (ret)
-                                goto out;
-                } else if (!strcmp (task_type, "Remove brick")) {
+                if (!strcmp (task_type, "Remove brick")) {
                         ret = cli_xml_output_remove_brick_task_params
                                 (local->writer, dict, key);
                         if (ret)
@@ -3476,7 +3423,7 @@ out:
 }
 
 int
-cli_xml_output_vol_replace_brick (gf1_cli_replace_op op, dict_t *dict,
+cli_xml_output_vol_replace_brick (char *op, dict_t *dict,
                                   int op_ret, int op_errno, char *op_errstr)
 {
 #if (HAVE_LIB_XML)
@@ -3496,55 +3443,6 @@ cli_xml_output_vol_replace_brick (gf1_cli_replace_op op, dict_t *dict,
         if (ret)
                 goto out;
 
-        /* <volReplaceBrick> */
-        ret = xmlTextWriterStartElement (writer, (xmlChar *)"volReplaceBrick");
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        ret = dict_get_str (dict, GF_REPLACE_BRICK_TID_KEY, &task_id_str);
-        if (ret == 0) {
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"task-id",
-                                                       "%s", task_id_str);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-
-        ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"op",
-                                               "%d", op);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
-        if (GF_REPLACE_OP_STATUS == op) {
-                ret = dict_get_int32 (dict, "status", &status);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"status",
-                                                       "%d", status);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                ret = dict_get_uint64 (dict, "files", &files);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"files",
-                                                       "%"PRIu64, files);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-
-                if (status)
-                        goto cont;
-
-                ret = dict_get_str (dict, "current_file", &current_file);
-                if (ret)
-                        goto out;
-                ret = xmlTextWriterWriteFormatElement (writer,
-                                                       (xmlChar *)"currentFile",
-                                                       "%s", current_file);
-                XML_RET_CHECK_AND_GOTO (ret, out);
-        }
-cont:
-        /* </volReplaceBrick> */
-        ret = xmlTextWriterEndElement (writer);
-        XML_RET_CHECK_AND_GOTO (ret, out);
-
         ret = cli_end_xml_output (writer, doc);
 
 out:
diff --git a/cli/src/cli.h b/cli/src/cli.h
index 27558a7830c..3da58dd22d8 100644
--- a/cli/src/cli.h
+++ b/cli/src/cli.h
@@ -407,8 +407,8 @@ cli_xml_output_vol_remove_brick (gf_boolean_t status_op, dict_t *dict,
                                  int op_ret, int op_errno, char *op_errstr);
 
 int
-cli_xml_output_vol_replace_brick (gf1_cli_replace_op op, dict_t *dict,
-                                  int op_ret, int op_errno, char *op_errstr);
+cli_xml_output_vol_replace_brick (char *op, dict_t *dict, int op_ret,
+                                  int op_errno, char *op_errstr);
 
 int
 cli_xml_output_vol_create (dict_t *dict, int op_ret, int op_errno,
diff --git a/libglusterfs/src/glusterfs.h b/libglusterfs/src/glusterfs.h
index 513cf152b68..cfa5b75bd04 100644
--- a/libglusterfs/src/glusterfs.h
+++ b/libglusterfs/src/glusterfs.h
@@ -210,7 +210,6 @@
 
 #define GF_REBALANCE_TID_KEY     "rebalance-id"
 #define GF_REMOVE_BRICK_TID_KEY  "remove-brick-id"
-#define GF_REPLACE_BRICK_TID_KEY "replace-brick-id"
 
 #define UUID_CANONICAL_FORM_LEN  36
 
diff --git a/rpc/xdr/src/cli1-xdr.x b/rpc/xdr/src/cli1-xdr.x
index 1a1dfcc9e87..cdf8e725788 100644
--- a/rpc/xdr/src/cli1-xdr.x
+++ b/rpc/xdr/src/cli1-xdr.x
@@ -33,16 +33,6 @@
         GF_CLUSTER_TYPE_MAX
 };
 
- enum gf1_cli_replace_op {
-        GF_REPLACE_OP_NONE = 0,
-        GF_REPLACE_OP_START,
-        GF_REPLACE_OP_COMMIT,
-        GF_REPLACE_OP_PAUSE,
-        GF_REPLACE_OP_ABORT,
-        GF_REPLACE_OP_STATUS,
-        GF_REPLACE_OP_COMMIT_FORCE
-};
-
 enum gf_bitrot_type {
         GF_BITROT_OPTION_TYPE_NONE = 0,
         GF_BITROT_OPTION_TYPE_ENABLE,
diff --git a/tests/basic/pump.t b/tests/basic/pump.t
index e9e54a7a9ea..ab62f77224f 100644
--- a/tests/basic/pump.t
+++ b/tests/basic/pump.t
@@ -22,11 +22,8 @@ do
 done
 cd
 EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
-TEST $CLI volume replace-brick $V0 $H0:$B0/${V0}0 $H0:$B0/${V0}1 start
-EXPECT_WITHIN 600 "Y" gd_is_replace_brick_completed $H0 $V0 $H0:$B0/${V0}0 $H0:$B0/${V0}1
-TEST $CLI volume replace-brick $V0 $H0:$B0/${V0}0 $H0:$B0/${V0}1 commit
+TEST $CLI volume replace-brick $V0 $H0:$B0/${V0}0 $H0:$B0/${V0}1 commit force
 TEST $CLI volume stop $V0
-TEST diff -r --exclude=.glusterfs $B0/${V0}0 $B0/${V0}1
 
 files=""
 
diff --git a/tests/bugs/glusterd/bug-1094119-remove-replace-brick-support-from-glusterd.t b/tests/bugs/glusterd/bug-1094119-remove-replace-brick-support-from-glusterd.t
new file mode 100644
index 00000000000..43acfcf7289
--- /dev/null
+++ b/tests/bugs/glusterd/bug-1094119-remove-replace-brick-support-from-glusterd.t
@@ -0,0 +1,30 @@
+#!/bin/bash
+
+## Test case for BZ: 1094119  Remove replace-brick support from gluster
+
+. $(dirname $0)/../../include.rc
+. $(dirname $0)/../../volume.rc
+
+cleanup;
+
+# Start glusterd
+TEST glusterd
+TEST pidof glusterd
+
+## Lets create and start volume
+TEST $CLI volume create $V0 $H0:$B0/brick1 $H0:$B0/brick2
+TEST $CLI volume start $V0
+
+## Now with this patch replace-brick only accept following commad
+## volume replace-brick <VOLNAME> <SOURCE-BRICK> <NEW-BRICK> {commit force}
+## Apart form this replace brick command will failed.
+
+TEST ! $CLI volume replace-brick $V0 $H0:$B0/brick1 $H0:$B0/brick3 start
+TEST ! $CLI volume replace-brick $V0 $H0:$B0/brick1 $H0:$B0/brick3 status
+TEST ! $CLI volume replace-brick $V0 $H0:$B0/brick1 $H0:$B0/brick3 abort
+
+
+## replace-brick commit force command should success
+TEST $CLI volume replace-brick $V0 $H0:$B0/brick1 $H0:$B0/brick3 commit force
+
+cleanup;
diff --git a/tests/bugs/glusterd/bug-1095097.t b/tests/bugs/glusterd/bug-1095097.t
index 0fe29f06630..0a616f7831e 100755
--- a/tests/bugs/glusterd/bug-1095097.t
+++ b/tests/bugs/glusterd/bug-1095097.t
@@ -15,7 +15,5 @@ EXPECT 'Started' volinfo_field $V0 'Status';
 
 TEST $CLI volume profile $V0 start
 TEST $CLI volume profile $V0 info
-TEST $CLI volume replace-brick $V0 $H0:$B0/brick1 $H0:$B0/brick2 start
-TEST $CLI volume replace-brick $V0 $H0:$B0/brick1 $H0:$B0/brick2 status
 
 cleanup;
diff --git a/tests/bugs/glusterd/bug-857330/normal.t b/tests/bugs/glusterd/bug-857330/normal.t
index 02018f244a8..6377b59070d 100755
--- a/tests/bugs/glusterd/bug-857330/normal.t
+++ b/tests/bugs/glusterd/bug-857330/normal.t
@@ -41,19 +41,7 @@ EXPECT_WITHIN 300 $PATTERN get-task-status
 ###################
 REP_BRICK_PAIR="$H0:$B0/${V0}2 $H0:$B0/${V0}3"
 
-COMMAND="volume replace-brick $V0 $REP_BRICK_PAIR start"
-PATTERN="ID:"
-TEST check-and-store-task-id
-
-COMMAND="volume status $V0"
-PATTERN="ID"
-EXPECT $TASK_ID get-task-id
-
-COMMAND="volume replace-brick $V0 $REP_BRICK_PAIR status"
-PATTERN="complete"
-EXPECT_WITHIN 300 $PATTERN get-task-status
-
-TEST $CLI volume replace-brick $V0 $REP_BRICK_PAIR commit;
+TEST $CLI volume replace-brick $V0 $REP_BRICK_PAIR commit force;
 
 ##################
 ## Remove-brick ##
diff --git a/tests/bugs/glusterd/bug-857330/xml.t b/tests/bugs/glusterd/bug-857330/xml.t
index 3aec3b89bbe..7d04fe199d3 100755
--- a/tests/bugs/glusterd/bug-857330/xml.t
+++ b/tests/bugs/glusterd/bug-857330/xml.t
@@ -47,29 +47,7 @@ EXPECT_WITHIN 300 $PATTERN get-task-status
 ###################
 ## Replace-brick ##
 ###################
-REP_BRICK_PAIR="$H0:$B0/${V0}2 $H0:$B0/${V0}3"
-
-COMMAND="volume replace-brick $V0 $REP_BRICK_PAIR start"
-PATTERN="task-id"
-TEST check-and-store-task-id-xml
-
-COMMAND="volume status $V0"
-PATTERN="id"
-EXPECT $TASK_ID get-task-id-xml
-
-COMMAND="volume replace-brick $V0 $REP_BRICK_PAIR status"
-PATTERN="task-id"
-EXPECT $TASK_ID get-task-id-xml
-
-## TODO: Add more tests for replace-brick pause|abort
-
-COMMAND="volume replace-brick $V0 $REP_BRICK_PAIR status"
-PATTERN="complete"
-EXPECT_WITHIN 300 $PATTERN get-task-status
-
-COMMAND="volume replace-brick $V0 $REP_BRICK_PAIR commit"
-PATTERN="task-id"
-EXPECT $TASK_ID get-task-id-xml
+TEST $CLI volume replace-brick $V0 $H0:$B0/${V0}2 $H0:$B0/${V0}3 commit force
 
 ##################
 ## Remove-brick ##
diff --git a/xlators/mgmt/glusterd/src/glusterd-brick-ops.c b/xlators/mgmt/glusterd/src/glusterd-brick-ops.c
index 5326e25a787..f80b5a8078b 100644
--- a/xlators/mgmt/glusterd/src/glusterd-brick-ops.c
+++ b/xlators/mgmt/glusterd/src/glusterd-brick-ops.c
@@ -1419,16 +1419,6 @@ glusterd_op_stage_add_brick (dict_t *dict, char **op_errstr, dict_t *rsp_dict)
         if (ret)
                 goto out;
 
-        if (glusterd_is_rb_ongoing (volinfo)) {
-                snprintf (msg, sizeof (msg), "Replace brick is in progress on "
-                          "volume %s. Please retry after replace-brick "
-                          "operation is committed or aborted", volname);
-                gf_log (THIS->name, GF_LOG_ERROR, "%s", msg);
-                *op_errstr = gf_strdup (msg);
-                ret = -1;
-                goto out;
-        }
-
         if (glusterd_is_defrag_on(volinfo)) {
                 snprintf (msg, sizeof(msg), "Volume name %s rebalance is in "
                           "progress. Please retry after completion", volname);
@@ -1611,16 +1601,6 @@ glusterd_op_stage_remove_brick (dict_t *dict, char **op_errstr)
         if (ret)
                 goto out;
 
-        if (glusterd_is_rb_ongoing (volinfo)) {
-                snprintf (msg, sizeof (msg), "Replace brick is in progress on "
-                          "volume %s. Please retry after replace-brick "
-                          "operation is committed or aborted", volname);
-                gf_log (this->name, GF_LOG_ERROR, "%s", msg);
-                *op_errstr = gf_strdup (msg);
-                ret = -1;
-                goto out;
-        }
-
         ret = dict_get_int32 (dict, "command", &flag);
         if (ret) {
                 gf_log (this->name, GF_LOG_ERROR,
diff --git a/xlators/mgmt/glusterd/src/glusterd-geo-rep.c b/xlators/mgmt/glusterd/src/glusterd-geo-rep.c
index 24768e38231..6b95beed490 100644
--- a/xlators/mgmt/glusterd/src/glusterd-geo-rep.c
+++ b/xlators/mgmt/glusterd/src/glusterd-geo-rep.c
@@ -2758,15 +2758,6 @@ glusterd_op_stage_gsync_set (dict_t *dict, char **op_errstr)
                         goto out;
                 }
 
-                /* don't attempt to start gsync if replace-brick is
-                 * in progress */
-                if (glusterd_is_rb_ongoing (volinfo)) {
-                        snprintf (errmsg, sizeof(errmsg), "replace-brick is in"
-                                   " progress, not starting geo-replication");
-                        ret = -1;
-                        goto out;
-                }
-
                 ret = glusterd_op_verify_gsync_start_options (volinfo, slave,
                                                               conf_path,
                                                               statefile,
diff --git a/xlators/mgmt/glusterd/src/glusterd-op-sm.c b/xlators/mgmt/glusterd/src/glusterd-op-sm.c
index 04cc75f545d..bd5d012e3ed 100644
--- a/xlators/mgmt/glusterd/src/glusterd-op-sm.c
+++ b/xlators/mgmt/glusterd/src/glusterd-op-sm.c
@@ -2496,41 +2496,6 @@ out:
 }
 
 static int
-_add_brick_name_to_dict (dict_t *dict, char *key, glusterd_brickinfo_t *brick)
-{
-        int     ret = -1;
-        char    tmp[1024] = {0,};
-        char    *brickname = NULL;
-        xlator_t *this = NULL;
-
-        GF_ASSERT (dict);
-        GF_ASSERT (key);
-        GF_ASSERT (brick);
-
-        this = THIS;
-        GF_ASSERT (this);
-
-        snprintf (tmp, sizeof (tmp), "%s:%s", brick->hostname, brick->path);
-        brickname = gf_strdup (tmp);
-        if (!brickname) {
-                gf_log (this->name, GF_LOG_ERROR, "Failed to dup brick name");
-                goto out;
-        }
-
-        ret = dict_set_dynstr (dict, key, brickname);
-        if (ret) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Failed to add brick name to dict");
-                goto out;
-        }
-        brickname = NULL;
-out:
-        if (brickname)
-                GF_FREE (brickname);
-        return ret;
-}
-
-static int
 _add_remove_bricks_to_dict (dict_t *dict, glusterd_volinfo_t *volinfo,
                             char *prefix)
 {
@@ -2624,25 +2589,6 @@ _add_task_to_dict (dict_t *dict, glusterd_volinfo_t *volinfo, int op, int index)
                 status = volinfo->rebal.defrag_status;
                 break;
 
-        case GD_OP_REPLACE_BRICK:
-                snprintf (key, sizeof (key), "task%d.src-brick", index);
-                ret = _add_brick_name_to_dict (dict, key,
-                                               volinfo->rep_brick.src_brick);
-                if (ret)
-                        goto out;
-                memset (key, 0, sizeof (key));
-
-                snprintf (key, sizeof (key), "task%d.dst-brick", index);
-                ret = _add_brick_name_to_dict (dict, key,
-                                               volinfo->rep_brick.dst_brick);
-                if (ret)
-                        goto out;
-                memset (key, 0, sizeof (key));
-
-                uuid_str = gf_strdup (uuid_utoa (volinfo->rep_brick.rb_id));
-                status = volinfo->rep_brick.rb_status;
-                break;
-
         default:
                 ret = -1;
                 gf_log (this->name, GF_LOG_ERROR, "%s operation doesn't have a"
@@ -2707,17 +2653,6 @@ glusterd_aggregate_task_status (dict_t *rsp_dict, glusterd_volinfo_t *volinfo)
                 tasks++;
         }
 
-        if (!gf_uuid_is_null (volinfo->rep_brick.rb_id)) {
-                ret = _add_task_to_dict (rsp_dict, volinfo, GD_OP_REPLACE_BRICK,
-                                         tasks);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "Failed to add task details to dict");
-                        goto out;
-                }
-                tasks++;
-        }
-
         ret = dict_set_int32 (rsp_dict, "tasks", tasks);
         if (ret) {
                 gf_log (this->name, GF_LOG_ERROR,
@@ -3791,67 +3726,6 @@ out:
 
 }
 
-static int32_t
-glusterd_op_start_rb_timer (dict_t *dict, uuid_t *txn_id)
-{
-        int32_t         op = 0;
-        struct timespec timeout = {0, };
-        glusterd_conf_t *priv = NULL;
-        int32_t         ret = -1;
-        dict_t          *rb_ctx = NULL;
-        uuid_t          *rb_txn_id = NULL;
-
-        GF_ASSERT (dict);
-        priv = THIS->private;
-
-        ret = dict_get_int32 (dict, "operation", &op);
-        if (ret) {
-                gf_log ("", GF_LOG_DEBUG,
-                        "dict_get on operation failed");
-                goto out;
-        }
-
-        if (op != GF_REPLACE_OP_START) {
-                ret = glusterd_op_sm_inject_all_acc (txn_id);
-                goto out;
-        }
-
-        rb_txn_id = GF_CALLOC (1, sizeof(uuid_t), gf_common_mt_uuid_t);
-        if (!rb_txn_id)
-                goto out;
-
-        gf_uuid_copy (*rb_txn_id, *txn_id);
-        timeout.tv_sec  = 5;
-        timeout.tv_nsec = 0;
-
-        rb_ctx = dict_copy (dict, rb_ctx);
-        if (!rb_ctx) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Couldn't copy "
-                        "replace brick context. Can't start replace brick");
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_set_bin (rb_ctx, "transaction_id",
-                            rb_txn_id, sizeof (*rb_txn_id));
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR,
-                       "Failed to set transaction id.");
-                goto out;
-        } else
-               gf_log ("", GF_LOG_DEBUG,
-                        "transaction_id = %s", uuid_utoa (*rb_txn_id));
-
-        priv->timer = gf_timer_call_after (THIS->ctx, timeout,
-                                           glusterd_do_replace_brick,
-                                           (void *) rb_ctx);
-
-        ret = 0;
-
-out:
-        return ret;
-}
-
 /* This function takes a dict and converts the uuid values of key specified
  * into hostnames
  */
@@ -4342,15 +4216,14 @@ glusterd_op_commit_hook (glusterd_op_t op, dict_t *op_ctx,
 static int
 glusterd_op_ac_send_commit_op (glusterd_op_sm_event_t *event, void *ctx)
 {
-        int                     ret = 0;
-        rpc_clnt_procedure_t    *proc = NULL;
-        glusterd_conf_t         *priv = NULL;
-        xlator_t                *this = NULL;
-        dict_t                  *dict = NULL;
-        dict_t                  *op_dict = NULL;
-        glusterd_peerinfo_t     *peerinfo = NULL;
-        char                    *op_errstr  = NULL;
-        glusterd_op_t           op = GD_OP_NONE;
+        int                     ret           = 0;
+        rpc_clnt_procedure_t    *proc         = NULL;
+        glusterd_conf_t         *priv         = NULL;
+        xlator_t                *this         = NULL;
+        dict_t                  *dict         = NULL;
+        glusterd_peerinfo_t     *peerinfo     = NULL;
+        char                    *op_errstr    = NULL;
+        glusterd_op_t           op            = GD_OP_NONE;
         uint32_t                pending_count = 0;
 
         this = THIS;
@@ -4359,7 +4232,6 @@ glusterd_op_ac_send_commit_op (glusterd_op_sm_event_t *event, void *ctx)
         GF_ASSERT (priv);
 
         op      = glusterd_op_get_op ();
-        op_dict = glusterd_op_get_ctx ();
 
         ret = glusterd_op_build_payload (&dict, &op_errstr, NULL);
         if (ret) {
@@ -4434,9 +4306,7 @@ out:
 
         if (!opinfo.pending_count) {
                 if (op == GD_OP_REPLACE_BRICK) {
-                        ret = glusterd_op_start_rb_timer (op_dict,
-                                                          &event->txn_id);
-
+                        ret = glusterd_op_sm_inject_all_acc (&event->txn_id);
                 } else {
                         glusterd_op_modify_op_ctx (op, NULL);
                         ret = glusterd_op_sm_inject_all_acc (&event->txn_id);
@@ -4569,7 +4439,6 @@ out:
 static int
 glusterd_op_ac_rcvd_commit_op_acc (glusterd_op_sm_event_t *event, void *ctx)
 {
-        dict_t                 *op_ctx            = NULL;
         int                     ret               = 0;
         gf_boolean_t            commit_ack_inject = _gf_true;
         glusterd_op_t           op                = GD_OP_NONE;
@@ -4587,15 +4456,7 @@ glusterd_op_ac_rcvd_commit_op_acc (glusterd_op_sm_event_t *event, void *ctx)
                 goto out;
 
         if (op == GD_OP_REPLACE_BRICK) {
-                op_ctx = glusterd_op_get_ctx ();
-                if (!op_ctx) {
-                        gf_log (this->name, GF_LOG_CRITICAL, "Operation "
-                                "context is not present.");
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = glusterd_op_start_rb_timer (op_ctx, &event->txn_id);
+                ret = glusterd_op_sm_inject_all_acc (&event->txn_id);
                 if (ret) {
                         gf_log (this->name, GF_LOG_ERROR, "Couldn't start "
                                 "replace-brick operation.");
diff --git a/xlators/mgmt/glusterd/src/glusterd-rebalance.c b/xlators/mgmt/glusterd/src/glusterd-rebalance.c
index 840438df29a..84d9210a105 100644
--- a/xlators/mgmt/glusterd/src/glusterd-rebalance.c
+++ b/xlators/mgmt/glusterd/src/glusterd-rebalance.c
@@ -72,15 +72,6 @@ glusterd_defrag_start_validate (glusterd_volinfo_t *volinfo, char *op_errstr,
                 goto out;
         }
 
-        if (glusterd_is_rb_started (volinfo) ||
-            glusterd_is_rb_paused (volinfo)) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "Rebalance failed as replace brick is in progress on volume %s",
-                        volinfo->volname);
-                snprintf (op_errstr, len, "Rebalance failed as replace brick is in progress on "
-                          "volume %s", volinfo->volname);
-                goto out;
-        }
         ret = 0;
 out:
         gf_log (this->name, GF_LOG_DEBUG, "Returning %d", ret);
diff --git a/xlators/mgmt/glusterd/src/glusterd-replace-brick.c b/xlators/mgmt/glusterd/src/glusterd-replace-brick.c
index 92cfcd2fa95..818b58a724f 100644
--- a/xlators/mgmt/glusterd/src/glusterd-replace-brick.c
+++ b/xlators/mgmt/glusterd/src/glusterd-replace-brick.c
@@ -38,43 +38,6 @@
 extern uuid_t global_txn_id;
 
 int
-glusterd_get_replace_op_str (gf1_cli_replace_op op, char *op_str)
-{
-        int     ret = -1;
-
-        if (!op_str)
-                goto out;
-
-        switch (op) {
-                case GF_REPLACE_OP_START:
-                        strcpy (op_str, "start");
-                        break;
-                case GF_REPLACE_OP_COMMIT:
-                        strcpy (op_str, "commit");
-                        break;
-                case GF_REPLACE_OP_PAUSE:
-                        strcpy (op_str, "pause");
-                        break;
-                case GF_REPLACE_OP_ABORT:
-                        strcpy (op_str, "abort");
-                        break;
-                case GF_REPLACE_OP_STATUS:
-                        strcpy (op_str, "status");
-                        break;
-                case GF_REPLACE_OP_COMMIT_FORCE:
-                        strcpy (op_str, "commit-force");
-                        break;
-                default:
-                        strcpy (op_str, "unknown");
-                        break;
-        }
-
-        ret = 0;
-out:
-        return ret;
-}
-
-int
 __glusterd_handle_replace_brick (rpcsvc_request_t *req)
 {
         int32_t                         ret = -1;
@@ -83,7 +46,6 @@ __glusterd_handle_replace_brick (rpcsvc_request_t *req)
         char                            *src_brick = NULL;
         char                            *dst_brick = NULL;
         int32_t                         op = 0;
-        char                            operation[256];
         glusterd_op_t                   cli_op = GD_OP_REPLACE_BRICK;
         char                            *volname = NULL;
         char                            msg[2048] = {0,};
@@ -152,10 +114,9 @@ __glusterd_handle_replace_brick (rpcsvc_request_t *req)
                 goto out;
         }
 
-        (void) glusterd_get_replace_op_str (op, operation);
         gf_log (this->name, GF_LOG_DEBUG, "dst brick=%s", dst_brick);
-        gf_log (this->name, GF_LOG_INFO, "Received replace brick %s request",
-                operation);
+        gf_log (this->name, GF_LOG_INFO, "Received replace brick commit-force "
+                "request operation");
 
         ret = glusterd_op_begin (req, GD_OP_REPLACE_BRICK, dict,
                                  msg, sizeof (msg));
@@ -209,7 +170,7 @@ glusterd_op_stage_replace_brick (dict_t *dict, char **op_errstr,
         char                                    *src_brick          = NULL;
         char                                    *dst_brick          = NULL;
         char                                    *volname            = NULL;
-        int                                      replace_op         = 0;
+        char                                    *replace_op         = NULL;
         glusterd_volinfo_t                      *volinfo            = NULL;
         glusterd_brickinfo_t                    *src_brickinfo      = NULL;
         char                                    *host               = NULL;
@@ -259,7 +220,7 @@ glusterd_op_stage_replace_brick (dict_t *dict, char **op_errstr,
                 goto out;
         }
 
-        ret = dict_get_int32 (dict, "operation", (int32_t *)&replace_op);
+        ret = dict_get_str (dict, "operation", &replace_op);
         if (ret) {
                 gf_log (this->name, GF_LOG_DEBUG,
                         "dict get on replace-brick operation failed");
@@ -312,99 +273,9 @@ glusterd_op_stage_replace_brick (dict_t *dict, char **op_errstr,
 
         ctx = glusterd_op_get_ctx();
 
-        switch (replace_op) {
-        case GF_REPLACE_OP_START:
-                if (glusterd_is_rb_started (volinfo)) {
-                        snprintf (msg, sizeof (msg), "Replace brick is already "
-                                  "started for volume");
-                        gf_log (this->name, GF_LOG_ERROR, "%s", msg);
-                        *op_errstr = gf_strdup (msg);
-                        ret = -1;
-                        goto out;
-                }
-                if (is_origin_glusterd (dict)) {
-                        if (!ctx) {
-                                ret = -1;
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "Failed to get op_ctx");
-                                goto out;
-                        }
-
-                        ret = glusterd_generate_and_set_task_id
-                                (ctx, GF_REPLACE_BRICK_TID_KEY);
-                        if (ret) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "Failed to generate task-id");
-                                goto out;
-                        }
-
-                } else {
-                        ret = dict_get_str (dict, GF_REPLACE_BRICK_TID_KEY,
-                                            &task_id_str);
-                        if (ret) {
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "Missing replace-brick-id");
-                                ret = 0;
-                        }
-                }
-                is_force = dict_get_str_boolean (dict, "force", _gf_false);
-
-                break;
-
-        case GF_REPLACE_OP_PAUSE:
-                if (glusterd_is_rb_paused (volinfo)) {
-                        gf_log (this->name, GF_LOG_ERROR, "Replace brick is "
-                                "already paused for volume ");
-                        ret = -1;
-                        goto out;
-                } else if (!glusterd_is_rb_started(volinfo)) {
-                        gf_log (this->name, GF_LOG_ERROR, "Replace brick is not"
-                                " started for volume ");
-                        ret = -1;
-                        goto out;
-                }
-                break;
-
-        case GF_REPLACE_OP_ABORT:
-                if (!glusterd_is_rb_ongoing (volinfo)) {
-                        gf_log (this->name, GF_LOG_ERROR, "Replace brick is not"
-                                " started or paused for volume ");
-                        ret = -1;
-                        goto out;
-                }
-                break;
-
-        case GF_REPLACE_OP_COMMIT:
-                if (!glusterd_is_rb_ongoing (volinfo)) {
-                        gf_log (this->name, GF_LOG_ERROR, "Replace brick is not "
-                                "started for volume ");
-                        ret = -1;
-                        goto out;
-                }
-                break;
-
-        case GF_REPLACE_OP_COMMIT_FORCE:
+        if (!strcmp(replace_op, "GF_REPLACE_OP_COMMIT_FORCE")) {
                 is_force = _gf_true;
-                break;
-
-        case GF_REPLACE_OP_STATUS:
-
-                if (glusterd_is_rb_ongoing (volinfo) == _gf_false) {
-                        ret = gf_asprintf (op_errstr, "replace-brick not"
-                                           " started on volume %s",
-                                           volinfo->volname);
-                        if (ret < 0) {
-                                *op_errstr = NULL;
-                                goto out;
-                        }
-
-                        gf_log (this->name, GF_LOG_ERROR, "%s", *op_errstr);
-                        ret = -1;
-                        goto out;
-                }
-                break;
-
-        default:
+        } else {
                 ret = -1;
                 goto out;
         }
@@ -446,16 +317,6 @@ glusterd_op_stage_replace_brick (dict_t *dict, char **op_errstr,
 
                 GLUSTERD_GET_BRICK_PIDFILE (pidfile, volinfo, src_brickinfo,
                                             priv);
-                if ((replace_op != GF_REPLACE_OP_COMMIT_FORCE) &&
-                    !gf_is_service_running (pidfile, NULL)) {
-                        snprintf(msg, sizeof(msg), "Source brick %s:%s "
-                                 "is not online.", src_brickinfo->hostname,
-                                 src_brickinfo->path);
-                        *op_errstr = gf_strdup (msg);
-                        ret = -1;
-                        goto out;
-                }
-
 
         }
 
@@ -489,9 +350,7 @@ glusterd_op_stage_replace_brick (dict_t *dict, char **op_errstr,
                 goto out;
         }
 
-       if (!glusterd_is_rb_ongoing (volinfo) &&
-            (replace_op == GF_REPLACE_OP_START ||
-             replace_op == GF_REPLACE_OP_COMMIT_FORCE)) {
+        if (!strcmp(replace_op, "GF_REPLACE_OP_COMMIT_FORCE")) {
 
                 volinfo->rep_brick.src_brick = src_brickinfo;
                 volinfo->rep_brick.dst_brick = dst_brickinfo;
@@ -507,8 +366,7 @@ glusterd_op_stage_replace_brick (dict_t *dict, char **op_errstr,
                 goto out;
        }
 
-        if (!glusterd_is_rb_ongoing (volinfo) &&
-            gf_is_local_addr (host)) {
+        if (gf_is_local_addr (host)) {
                 ret = glusterd_validate_and_create_brickpath (dst_brickinfo,
                                                   volinfo->volume_id,
                                                   op_errstr, is_force);
@@ -573,27 +431,6 @@ glusterd_op_stage_replace_brick (dict_t *dict, char **op_errstr,
                 }
         }
 
-        if (replace_op == GF_REPLACE_OP_START &&
-            gf_is_local_addr (volinfo->rep_brick.dst_brick->hostname)) {
-                port = pmap_registry_alloc (THIS);
-                if (!port) {
-                        gf_log (THIS->name, GF_LOG_CRITICAL,
-                                "No free ports available");
-                        ret = -1;
-                        goto out;
-                }
-
-                ctx = glusterd_op_get_ctx();
-                ret = dict_set_int32 ((ctx)?ctx:rsp_dict, "dst-brick-port",
-                                      port);
-                if (ret) {
-                        gf_log (THIS->name, GF_LOG_ERROR, "Failed to set dst "
-                                "brick port");
-                        goto out;
-                }
-                volinfo->rep_brick.dst_brick->port = port;
-        }
-
         ret = 0;
 
 out:
@@ -604,555 +441,6 @@ out:
 }
 
 static int
-rb_set_mntfd (int mntfd)
-{
-        int     ret = -1;
-        dict_t *ctx = NULL;
-
-        ctx = glusterd_op_get_ctx ();
-        if (!ctx) {
-                gf_log (THIS->name, GF_LOG_CRITICAL, "Failed to get op ctx");
-                goto out;
-        }
-        ret = dict_set_int32 (ctx, "mntfd", mntfd);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_DEBUG, "Failed to set mnt fd "
-                        "in op ctx");
-out:
-        return ret;
-}
-
-static int
-rb_get_mntfd (int *mntfd)
-{
-        int     ret = -1;
-        dict_t *ctx = NULL;
-
-        ctx = glusterd_op_get_ctx ();
-        if (!ctx) {
-                gf_log (THIS->name, GF_LOG_CRITICAL, "Failed to get op ctx");
-                goto out;
-        }
-        ret = dict_get_int32 (ctx, "mntfd", mntfd);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_DEBUG, "Failed to get mnt fd "
-                        "from op ctx");
-out:
-        return ret;
-}
-
-static int
-rb_regenerate_volfiles (glusterd_volinfo_t *volinfo,
-                        glusterd_brickinfo_t *brickinfo,
-                        int32_t pump_needed)
-{
-        dict_t *dict = NULL;
-        int ret = 0;
-
-        dict = volinfo->dict;
-
-        gf_log ("", GF_LOG_DEBUG,
-                "attempting to set pump value=%d", pump_needed);
-
-        ret = dict_set_int32 (dict, "enable-pump", pump_needed);
-        if (ret) {
-                gf_log ("", GF_LOG_DEBUG,
-                        "could not dict_set enable-pump");
-                goto out;
-        }
-
-        ret = glusterd_create_rb_volfiles (volinfo, brickinfo);
-
-        dict_del (dict, "enable-pump");
-
-out:
-        return ret;
-}
-
-static int
-rb_src_brick_restart (glusterd_volinfo_t *volinfo,
-                      glusterd_brickinfo_t *src_brickinfo,
-                      int activate_pump)
-{
-        int              ret  = 0;
-        xlator_t        *this = NULL;
-        glusterd_conf_t *priv = NULL;
-
-        this = THIS;
-        GF_ASSERT (this);
-
-        priv = this->private;
-        GF_ASSERT (priv);
-
-        gf_log ("", GF_LOG_DEBUG,
-                "Attempting to kill src");
-
-        ret = priv->nfs_svc.stop (&(priv->nfs_svc), SIGKILL);
-
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Unable to stop nfs, ret: %d",
-                        ret);
-        }
-
-        ret = glusterd_volume_stop_glusterfs (volinfo, src_brickinfo,
-                                              _gf_false);
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Unable to stop "
-                        "glusterfs, ret: %d", ret);
-                goto out;
-        }
-
-        glusterd_delete_volfile (volinfo, src_brickinfo);
-
-        if (activate_pump) {
-                ret = rb_regenerate_volfiles (volinfo, src_brickinfo, 1);
-                if (ret) {
-                        gf_log ("", GF_LOG_DEBUG,
-                                "Could not regenerate volfiles with pump");
-                        goto out;
-                }
-        } else {
-                ret = rb_regenerate_volfiles (volinfo, src_brickinfo, 0);
-                if (ret) {
-                        gf_log ("", GF_LOG_DEBUG,
-                                "Could not regenerate volfiles without pump");
-                        goto out;
-                }
-
-        }
-
-        sleep (2);
-        ret = glusterd_volume_start_glusterfs (volinfo, src_brickinfo,
-                                               _gf_false);
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Unable to start "
-                        "glusterfs, ret: %d", ret);
-                goto out;
-        }
-
-out:
-        ret = priv->nfs_svc.start (&(priv->nfs_svc), PROC_START_NO_WAIT);
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Unable to start nfs, ret: %d",
-                        ret);
-        }
-        return ret;
-}
-
-static int
-rb_send_xattr_command (glusterd_volinfo_t *volinfo,
-                       glusterd_brickinfo_t *src_brickinfo,
-                       glusterd_brickinfo_t *dst_brickinfo,
-                       const char *xattr_key, const char *value)
-{
-        int             ret   = -1;
-        int             mntfd = -1;
-
-        ret = rb_get_mntfd (&mntfd);
-        if (ret)
-                goto out;
-
-        ret = sys_fsetxattr (mntfd, xattr_key, value, strlen (value) + 1, 0);
-        if (ret)
-                gf_log (THIS->name, GF_LOG_DEBUG, "setxattr on key: "
-                        "%s, reason: %s", xattr_key, strerror (errno));
-
-out:
-        return ret;
-}
-
-static int
-rb_spawn_dst_brick (glusterd_volinfo_t *volinfo,
-                    glusterd_brickinfo_t *brickinfo)
-{
-        glusterd_conf_t    *priv           = NULL;
-        runner_t            runner         = {0,};
-        int                 ret            = -1;
-        int32_t             port           = 0;
-
-        priv = THIS->private;
-
-        port = brickinfo->port;
-        GF_ASSERT (port);
-
-        runinit (&runner);
-        runner_add_arg (&runner, SBIN_DIR"/glusterfs");
-        runner_argprintf (&runner, "-f" "%s/vols/%s/"RB_DSTBRICKVOL_FILENAME,
-                          priv->workdir, volinfo->volname);
-        runner_argprintf (&runner, "-p" "%s/vols/%s/"RB_DSTBRICK_PIDFILE,
-                          priv->workdir, volinfo->volname);
-        runner_add_arg (&runner, "--xlator-option");
-        runner_argprintf (&runner, "src-server.listen-port=%d", port);
-        if (volinfo->memory_accounting)
-                runner_add_arg (&runner, "--mem-accounting");
-
-        ret = runner_run_nowait (&runner);
-        if (ret) {
-                pmap_registry_remove (THIS, 0, brickinfo->path,
-                                      GF_PMAP_PORT_BRICKSERVER, NULL);
-                gf_log ("", GF_LOG_DEBUG,
-                        "Could not start glusterfs");
-                goto out;
-        }
-
-        gf_log ("", GF_LOG_DEBUG,
-                "Successfully started glusterfs: brick=%s:%s",
-                brickinfo->hostname, brickinfo->path);
-
-        ret = 0;
-
-out:
-        return ret;
-}
-
-static int
-rb_spawn_glusterfs_client (glusterd_volinfo_t *volinfo,
-                           glusterd_brickinfo_t *brickinfo)
-{
-        xlator_t           *this            = NULL;
-        glusterd_conf_t    *priv            = NULL;
-        runner_t            runner          = {0,};
-        struct stat         buf             = {0,};
-        char                mntpt[PATH_MAX] = {0,};
-        int                 mntfd           = -1;
-        int                 ret             = -1;
-
-        this = THIS;
-        priv = this->private;
-
-        GLUSTERD_GET_RB_MNTPT (mntpt, sizeof (mntpt), volinfo);
-        runinit (&runner);
-        runner_add_arg (&runner, SBIN_DIR"/glusterfs");
-        runner_argprintf (&runner, "-f" "%s/vols/%s/"RB_CLIENTVOL_FILENAME,
-                          priv->workdir, volinfo->volname);
-        runner_add_arg (&runner, mntpt);
-        if (volinfo->memory_accounting)
-                runner_add_arg (&runner, "--mem-accounting");
-
-        ret = runner_run_reuse (&runner);
-        if (ret) {
-                runner_log (&runner, this->name, GF_LOG_DEBUG,
-                            "Could not start glusterfs");
-                runner_end (&runner);
-                goto out;
-        } else {
-                runner_log (&runner, this->name, GF_LOG_DEBUG,
-                            "Successfully started  glusterfs");
-                runner_end (&runner);
-        }
-
-        ret = stat (mntpt, &buf);
-        if (ret) {
-                 gf_log (this->name, GF_LOG_DEBUG, "stat on mount point %s "
-                         "failed", mntpt);
-                 goto out;
-        }
-
-        mntfd = open (mntpt, O_DIRECTORY);
-        if (mntfd == -1)
-                goto out;
-
-        ret = rb_set_mntfd (mntfd);
-        if (ret)
-                goto out;
-
-
-out:
-
-        return ret;
-}
-
-static const char *client_volfile_str =  "volume mnt-client\n"
-        " type protocol/client\n"
-        " option remote-host %s\n"
-        " option remote-subvolume %s\n"
-        " option remote-port %d\n"
-        " option transport-type %s\n"
-        " option username %s\n"
-        " option password %s\n"
-        "end-volume\n"
-        "volume mnt-wb\n"
-        " type performance/write-behind\n"
-        " subvolumes mnt-client\n"
-        "end-volume\n";
-
-static int
-rb_generate_client_volfile (glusterd_volinfo_t *volinfo,
-                            glusterd_brickinfo_t *src_brickinfo)
-{
-        glusterd_conf_t  *priv                  = NULL;
-        xlator_t         *this                  = NULL;
-        FILE             *file                  = NULL;
-        char              filename[PATH_MAX]    = {0, };
-        int               ret                   = -1;
-        int               fd                    = -1;
-        char             *ttype                 = NULL;
-
-        this = THIS;
-        priv = this->private;
-
-        gf_log (this->name, GF_LOG_DEBUG, "Creating volfile");
-
-        snprintf (filename, PATH_MAX, "%s/vols/%s/%s",
-                  priv->workdir, volinfo->volname,
-                  RB_CLIENTVOL_FILENAME);
-
-        fd = open (filename, O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR);
-        if (fd < 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "%s", strerror (errno));
-                goto out;
-        }
-        sys_close (fd);
-
-        file = fopen (filename, "w+");
-        if (!file) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "Open of volfile failed");
-                ret = -1;
-                goto out;
-        }
-
-        GF_ASSERT (src_brickinfo->port);
-
-	ttype = glusterd_get_trans_type_rb (volinfo->transport_type);
-	if (NULL == ttype){
-		ret = -1;
-		goto out;
-	}
-
-        fprintf (file, client_volfile_str, src_brickinfo->hostname,
-                 src_brickinfo->path,
-                 src_brickinfo->port, ttype,
-                 glusterd_auth_get_username (volinfo),
-                 glusterd_auth_get_password (volinfo));
-
-        GF_FREE (ttype);
-
-        ret = 0;
-
-out:
-        if (file)
-                fclose (file);
-
-        return ret;
-}
-
-static const char *dst_brick_volfile_str = "volume src-posix\n"
-        " type storage/posix\n"
-        " option directory %s\n"
-        " option volume-id %s\n"
-        "end-volume\n"
-        "volume %s\n"
-        " type features/locks\n"
-        " subvolumes src-posix\n"
-        "end-volume\n"
-        "volume src-server\n"
-        " type protocol/server\n"
-        " option auth.login.%s.allow %s\n"
-        " option auth.login.%s.password %s\n"
-        " option auth.addr.%s.allow *\n"
-        " option transport-type %s\n"
-        " subvolumes %s\n"
-        "end-volume\n";
-
-static int
-rb_generate_dst_brick_volfile (glusterd_volinfo_t *volinfo,
-                               glusterd_brickinfo_t *dst_brickinfo)
-{
-        glusterd_conf_t    *priv                = NULL;
-        xlator_t           *this                = NULL;
-        FILE               *file                = NULL;
-        char                filename[PATH_MAX]  = {0, };
-        int                 ret                 = -1;
-        int                 fd                  = -1;
-        char               *trans_type          = NULL;
-
-        this = THIS;
-        priv = this->private;
-
-        gf_log (this->name, GF_LOG_DEBUG,
-                "Creating volfile");
-
-        snprintf (filename, PATH_MAX, "%s/vols/%s/%s",
-                  priv->workdir, volinfo->volname,
-                  RB_DSTBRICKVOL_FILENAME);
-
-        fd = sys_creat (filename, S_IRUSR | S_IWUSR);
-        if (fd < 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "%s", strerror (errno));
-                goto out;
-        }
-        sys_close (fd);
-
-        file = fopen (filename, "w+");
-        if (!file) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "Open of volfile failed");
-                ret = -1;
-                goto out;
-        }
-
-	trans_type = glusterd_get_trans_type_rb (volinfo->transport_type);
-	if (NULL == trans_type){
-		ret = -1;
-		goto out;
-	}
-
-        fprintf (file, dst_brick_volfile_str,
-                 dst_brickinfo->path,
-                 uuid_utoa (volinfo->volume_id),
-                 dst_brickinfo->path,
-                 dst_brickinfo->path,
-                 glusterd_auth_get_username (volinfo),
-                 glusterd_auth_get_username (volinfo),
-                 glusterd_auth_get_password (volinfo),
-                 dst_brickinfo->path,
-                 trans_type,
-                 dst_brickinfo->path);
-
-	GF_FREE (trans_type);
-
-        ret = 0;
-
-out:
-        if (file)
-                fclose (file);
-
-        return ret;
-}
-
-
-static int
-rb_mountpoint_mkdir (glusterd_volinfo_t *volinfo,
-                     glusterd_brickinfo_t *src_brickinfo)
-{
-        char             mntpt[PATH_MAX]        = {0,};
-        int              ret                    = -1;
-
-        GLUSTERD_GET_RB_MNTPT (mntpt, sizeof (mntpt), volinfo);
-        ret = mkdir (mntpt, 0777);
-        if (ret && (errno != EEXIST)) {
-                gf_log ("", GF_LOG_DEBUG, "mkdir failed, due to %s",
-                        strerror (errno));
-                goto out;
-        }
-
-        ret = 0;
-
-out:
-        return ret;
-}
-
-static int
-rb_destroy_maintenance_client (glusterd_volinfo_t *volinfo,
-                               glusterd_brickinfo_t *src_brickinfo)
-{
-        xlator_t         *this                        = NULL;
-        glusterd_conf_t  *priv                        = NULL;
-        char              volfile[PATH_MAX]           = {0,};
-        int               ret                         = -1;
-        int               mntfd                       = -1;
-        char              mntpt[PATH_MAX]             = {0,};
-
-        this = THIS;
-        priv = this->private;
-
-        ret = rb_get_mntfd (&mntfd);
-        if (ret)
-                goto out;
-
-        ret = close (mntfd);
-        if (ret) {
-                gf_log (this->name, GF_LOG_DEBUG, "Failed to close mount "
-                        "point directory");
-                goto out;
-        }
-
-        GLUSTERD_GET_RB_MNTPT (mntpt, sizeof (mntpt), volinfo);
-        ret = gf_umount_lazy (this->name, mntpt, 1);
-        if (ret) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "Lazy unmount failed on maintenance client");
-        } else {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "Successfully unmounted  maintenance client");
-        }
-
-        snprintf (volfile, PATH_MAX, "%s/vols/%s/%s", priv->workdir,
-                  volinfo->volname, RB_CLIENTVOL_FILENAME);
-
-        ret = unlink (volfile);
-        if (ret) {
-                gf_log ("", GF_LOG_DEBUG, "unlink of %s failed, reason: %s",
-                        volfile, strerror (errno));
-                goto out;
-        }
-
-        ret = 0;
-
-out:
-        return ret;
-}
-
-static int
-rb_spawn_maintenance_client (glusterd_volinfo_t *volinfo,
-                             glusterd_brickinfo_t *src_brickinfo)
-{
-        int ret = -1;
-
-        ret = rb_generate_client_volfile (volinfo, src_brickinfo);
-        if (ret) {
-                gf_log ("", GF_LOG_DEBUG, "Unable to generate client "
-                        "volfile");
-                goto out;
-        }
-
-        ret = rb_mountpoint_mkdir (volinfo, src_brickinfo);
-        if (ret) {
-                gf_log ("", GF_LOG_DEBUG, "Unable to mkdir "
-                        "mountpoint");
-                goto out;
-        }
-
-        ret = rb_spawn_glusterfs_client (volinfo, src_brickinfo);
-        if (ret) {
-                gf_log ("", GF_LOG_DEBUG, "Unable to start glusterfs");
-                goto out;
-        }
-
-        ret = 0;
-out:
-        return ret;
-}
-
-static int
-rb_spawn_destination_brick (glusterd_volinfo_t *volinfo,
-                            glusterd_brickinfo_t *dst_brickinfo)
-
-{
-        int ret = -1;
-
-        ret = rb_generate_dst_brick_volfile (volinfo, dst_brickinfo);
-        if (ret) {
-                gf_log ("", GF_LOG_DEBUG, "Unable to generate client "
-                        "volfile");
-                goto out;
-        }
-
-        ret = rb_spawn_dst_brick (volinfo, dst_brickinfo);
-        if (ret) {
-                gf_log ("", GF_LOG_DEBUG, "Unable to start glusterfs");
-                goto out;
-        }
-
-        ret = 0;
-out:
-        return ret;
-}
-
-static int
 rb_kill_destination_brick (glusterd_volinfo_t *volinfo,
                            glusterd_brickinfo_t *dst_brickinfo)
 {
@@ -1168,241 +456,13 @@ rb_kill_destination_brick (glusterd_volinfo_t *volinfo,
         return glusterd_service_stop ("brick", pidfile, SIGTERM, _gf_true);
 }
 
-static int
-rb_get_xattr_command (glusterd_volinfo_t *volinfo,
-                      glusterd_brickinfo_t *src_brickinfo,
-                      glusterd_brickinfo_t *dst_brickinfo,
-                      const char *xattr_key,
-                      char *value)
-{
-        int             ret    = -1;
-        int             mntfd  = -1;
-
-        ret = rb_get_mntfd (&mntfd);
-        if (ret)
-                goto out;
-
-        ret = sys_fgetxattr (mntfd, xattr_key, value, 8192);
-
-        if (ret < 0) {
-                gf_log (THIS->name, GF_LOG_DEBUG, "getxattr on key: %s "
-                        "failed, reason: %s", xattr_key, strerror (errno));
-                goto out;
-        }
-
-        ret = 0;
-out:
-        return ret;
-}
-
-static int
-rb_send_cmd (glusterd_volinfo_t *volinfo,
-             glusterd_brickinfo_t *src,
-             glusterd_brickinfo_t *dst,
-             gf1_cli_replace_op op)
-{
-        char         start_value[8192]          = {0,};
-        char         status_str[8192]           = {0,};
-        char        *status_reply               = NULL;
-        char        *tmp                        = NULL;
-        char        *save_ptr                   = NULL;
-        char         filename[PATH_MAX]         = {0,};
-        char        *current_file               = NULL;
-        uint64_t     files                      = 0;
-        int          status                     = 0;
-        dict_t      *ctx                        = NULL;
-        int          ret                        = 0;
-
-        GF_ASSERT (volinfo);
-        GF_ASSERT (src);
-        GF_ASSERT (dst);
-        GF_ASSERT ((op > GF_REPLACE_OP_NONE)
-                   && (op <= GF_REPLACE_OP_COMMIT_FORCE));
-
-        switch (op) {
-                case GF_REPLACE_OP_START:
-                {
-                        snprintf (start_value, sizeof (start_value),
-                                  "%s:%s:%d", dst->hostname, dst->path,
-                                  dst->port);
-                        ret = rb_send_xattr_command (volinfo, src, dst,
-                                                     RB_PUMP_CMD_START,
-                                                     start_value);
-                }
-                break;
-                case GF_REPLACE_OP_PAUSE:
-                {
-                        ret = rb_send_xattr_command (volinfo, src, dst,
-                                                     RB_PUMP_CMD_PAUSE,
-                                                     RB_PUMP_DEF_ARG);
-                }
-                break;
-                case GF_REPLACE_OP_ABORT:
-                {
-                        ret = rb_send_xattr_command (volinfo, src, dst,
-                                                     RB_PUMP_CMD_ABORT,
-                                                     RB_PUMP_DEF_ARG);
-                }
-                break;
-                case GF_REPLACE_OP_COMMIT:
-                {
-                        ret = rb_send_xattr_command (volinfo, src, dst,
-                                                     RB_PUMP_CMD_COMMIT,
-                                                     RB_PUMP_DEF_ARG);
-                }
-                break;
-                case GF_REPLACE_OP_STATUS:
-                {
-                        ret = rb_get_xattr_command (volinfo, src, dst,
-                                                    RB_PUMP_CMD_STATUS,
-                                                    status_str);
-                        if (ret)
-                                goto out;
-
-                        ctx = glusterd_op_get_ctx ();
-                        GF_ASSERT (ctx);
-                        if (!ctx) {
-                                ret = -1;
-                                gf_log (THIS->name, GF_LOG_CRITICAL,
-                                        "ctx is not present.");
-                                goto out;
-                        }
-
-                        /* Split status reply into different parts */
-                        tmp = strtok_r (status_str, ":", &save_ptr);
-                        if (!tmp) {
-                                ret = -1;
-                                gf_log (THIS->name, GF_LOG_ERROR,
-                                        "Couldn't tokenize status string");
-                                goto out;
-                        }
-                        sscanf (tmp, "status=%d", &status);
-                        ret = dict_set_int32 (ctx, "status", status);
-                        if (ret) {
-                                gf_log (THIS->name, GF_LOG_ERROR, "Couldn't "
-                                        "set rb status in context");
-                                goto out;
-                        }
-
-                        tmp = NULL;
-                        tmp = strtok_r (NULL, ":", &save_ptr);
-                        if (!tmp) {
-                                ret = -1;
-                                gf_log (THIS->name, GF_LOG_ERROR,
-                                        "Couldn't tokenize status string");
-                                goto out;
-                        }
-                        sscanf (tmp, "no_of_files=%"SCNu64, &files);
-                        ret = dict_set_uint64 (ctx, "files", files);
-                        if (ret) {
-                                gf_log (THIS->name, GF_LOG_ERROR, "Couldn't "
-                                        "set rb files in context");
-                                goto out;
-                        }
-
-                        if (status == 0) {
-                                tmp = NULL;
-                                tmp = strtok_r (NULL, ":", &save_ptr);
-                                if (!tmp) {
-                                        ret = -1;
-                                        gf_log (THIS->name, GF_LOG_ERROR,
-                                                "Couldn't tokenize status "
-                                                "string");
-                                        goto out;
-                                }
-                                sscanf (tmp, "current_file=%s", filename);
-                                current_file = gf_strdup (filename);
-                                ret = dict_set_dynstr (ctx, "current_file",
-                                                       current_file);
-                                if (ret) {
-                                        GF_FREE (current_file);
-                                        gf_log (THIS->name, GF_LOG_ERROR,
-                                                "Couldn't set rb current file "
-                                                "in context");
-                                        goto out;
-                                }
-                        }
-                        if (status) {
-                                ret = gf_asprintf (&status_reply,
-                                                  "Number of files migrated = %"
-                                                  PRIu64"\tMigration complete",
-                                                  files);
-                        } else {
-                                ret = gf_asprintf (&status_reply,
-                                                  "Number of files migrated = %"
-                                                  PRIu64"\tCurrent file = %s",
-                                                  files, filename);
-                        }
-                        if (ret == -1) {
-                                gf_log (THIS->name, GF_LOG_ERROR,
-                                        "Failed to create status_reply string");
-                                goto out;
-                        }
-                        ret = dict_set_dynstr (ctx, "status-reply",
-                                               status_reply);
-                        if (ret) {
-                                GF_FREE (status_reply);
-                                gf_log (THIS->name, GF_LOG_ERROR, "Couldn't "
-                                        "set rb status response in context.");
-                                goto out;
-                        }
-                }
-                break;
-                default:
-                {
-                        GF_ASSERT (0);
-                        ret = -1;
-                        gf_log (THIS->name, GF_LOG_CRITICAL, "Invalid replace"
-                                " brick subcommand.");
-                }
-                break;
-        }
-out:
-        return ret;
-}
-
-static int
-rb_do_operation (glusterd_volinfo_t *volinfo,
-                 glusterd_brickinfo_t *src_brickinfo,
-                 glusterd_brickinfo_t *dst_brickinfo,
-                 gf1_cli_replace_op op)
-{
-
-        int             ret             = -1;
-        char            op_str[256]     = {0, };
-        xlator_t        *this           = NULL;
-
-        this = THIS;
-
-        ret = rb_spawn_maintenance_client (volinfo, src_brickinfo);
-        if (ret) {
-                gf_log (this->name, GF_LOG_DEBUG, "Could not spawn "
-                        "maintenance client");
-                goto umount;
-        }
-
-        ret = rb_send_cmd (volinfo, src_brickinfo, dst_brickinfo, op);
-        if (ret) {
-                (void) glusterd_get_replace_op_str (op, op_str);
-                gf_log (this->name, GF_LOG_DEBUG, "Sending replace-brick "
-                        "sub-command %s failed.", op_str);
-        }
-
-umount:
-        if (rb_destroy_maintenance_client (volinfo, src_brickinfo))
-                gf_log (this->name, GF_LOG_DEBUG, "Failed to destroy "
-                        "maintenance client");
-
-         return ret;
-}
-
 /* Set src-brick's port number to be used in the maintenance mount
  * after all commit acks are received.
  */
 static int
 rb_update_srcbrick_port (glusterd_volinfo_t *volinfo,
                          glusterd_brickinfo_t *src_brickinfo,
-                         dict_t *rsp_dict, dict_t *req_dict, int32_t replace_op)
+                         dict_t *rsp_dict, dict_t *req_dict, char *replace_op)
 {
         xlator_t *this                  = NULL;
         dict_t   *ctx                   = NULL;
@@ -1412,13 +472,14 @@ rb_update_srcbrick_port (glusterd_volinfo_t *volinfo,
         char      brickname[PATH_MAX]   = {0,};
 
         this = THIS;
+        GF_ASSERT (this);
 
         dict_ret = dict_get_int32 (req_dict, "src-brick-port", &src_port);
         if (src_port)
                 src_brickinfo->port = src_port;
 
         if (gf_is_local_addr (src_brickinfo->hostname)) {
-                gf_log ("", GF_LOG_INFO,
+                gf_log (this->name, GF_LOG_INFO,
                         "adding src-brick port no");
 
                 if (volinfo->transport_type == GF_TRANSPORT_RDMA) {
@@ -1430,18 +491,18 @@ rb_update_srcbrick_port (glusterd_volinfo_t *volinfo,
 
                 src_brickinfo->port = pmap_registry_search (this,
                                       brickname, GF_PMAP_PORT_BRICKSERVER);
-                if (!src_brickinfo->port &&
-                    replace_op != GF_REPLACE_OP_COMMIT_FORCE ) {
-                        gf_log ("", GF_LOG_ERROR,
+                if (!src_brickinfo->port) {
+                        gf_log (this->name, GF_LOG_ERROR,
                                 "Src brick port not available");
                         ret = -1;
                         goto out;
                 }
 
                 if (rsp_dict) {
-                        ret = dict_set_int32 (rsp_dict, "src-brick-port", src_brickinfo->port);
+                        ret = dict_set_int32 (rsp_dict, "src-brick-port",
+                                              src_brickinfo->port);
                         if (ret) {
-                                gf_log ("", GF_LOG_DEBUG,
+                                gf_log (this->name, GF_LOG_DEBUG,
                                         "Could not set src-brick port no");
                                 goto out;
                         }
@@ -1449,9 +510,10 @@ rb_update_srcbrick_port (glusterd_volinfo_t *volinfo,
 
                 ctx = glusterd_op_get_ctx ();
                 if (ctx) {
-                        ret = dict_set_int32 (ctx, "src-brick-port", src_brickinfo->port);
+                        ret = dict_set_int32 (ctx, "src-brick-port",
+                                              src_brickinfo->port);
                         if (ret) {
-                                gf_log ("", GF_LOG_DEBUG,
+                                gf_log (this->name, GF_LOG_DEBUG,
                                         "Could not set src-brick port no");
                                 goto out;
                         }
@@ -1466,7 +528,7 @@ out:
 
 static int
 rb_update_dstbrick_port (glusterd_brickinfo_t *dst_brickinfo, dict_t *rsp_dict,
-                         dict_t *req_dict, int32_t replace_op)
+                         dict_t *req_dict, char *replace_op)
 {
         dict_t *ctx           = NULL;
         int     ret           = 0;
@@ -1587,18 +649,18 @@ out:
 int
 glusterd_op_replace_brick (dict_t *dict, dict_t *rsp_dict)
 {
-        int                                      ret = 0;
-        dict_t                                  *ctx  = NULL;
-        int                                      replace_op = 0;
-        glusterd_volinfo_t                      *volinfo = NULL;
-        char                                    *volname = NULL;
-        xlator_t                                *this = NULL;
-        glusterd_conf_t                         *priv = NULL;
-        char                                    *src_brick = NULL;
-        char                                    *dst_brick = NULL;
+        int                                      ret           = 0;
+        dict_t                                  *ctx           = NULL;
+        char                                    *replace_op    = NULL;
+        glusterd_volinfo_t                      *volinfo       = NULL;
+        char                                    *volname       = NULL;
+        xlator_t                                *this          = NULL;
+        glusterd_conf_t                         *priv          = NULL;
+        char                                    *src_brick     = NULL;
+        char                                    *dst_brick     = NULL;
         glusterd_brickinfo_t                    *src_brickinfo = NULL;
         glusterd_brickinfo_t                    *dst_brickinfo = NULL;
-        char                                    *task_id_str = NULL;
+        char                                    *task_id_str   = NULL;
 
         this = THIS;
         GF_ASSERT (this);
@@ -1628,7 +690,7 @@ glusterd_op_replace_brick (dict_t *dict, dict_t *rsp_dict)
                 goto out;
         }
 
-        ret = dict_get_int32 (dict, "operation", (int32_t *)&replace_op);
+        ret = dict_get_str (dict, "operation", &replace_op);
         if (ret) {
                 gf_log (this->name, GF_LOG_DEBUG,
                         "dict_get on operation failed");
@@ -1669,250 +731,66 @@ glusterd_op_replace_brick (dict_t *dict, dict_t *rsp_dict)
         if (ret)
                 goto out;
 
-	if ((GF_REPLACE_OP_START != replace_op)) {
-
-                /* Set task-id, if available, in op_ctx dict for operations
-                 * other than start
-                 */
-                if  (is_origin_glusterd (dict)) {
-                        ctx = glusterd_op_get_ctx();
-                        if (!ctx) {
-                                gf_log (this->name, GF_LOG_ERROR, "Failed to "
-                                        "get op_ctx");
-                                ret = -1;
-                                goto out;
-                        }
-                        if (!gf_uuid_is_null (volinfo->rep_brick.rb_id)) {
-                                ret = glusterd_copy_uuid_to_dict
-                                        (volinfo->rep_brick.rb_id, ctx,
-                                         GF_REPLACE_BRICK_TID_KEY);
-                                if (ret) {
-                                        gf_log (this->name, GF_LOG_ERROR,
-                                                "Failed to set "
-                                                "replace-brick-id");
-                                        goto out;
-                                }
-                        }
+                /* Set task-id, if available, in op_ctx dict for*/
+        if (is_origin_glusterd (dict)) {
+                ctx = glusterd_op_get_ctx();
+                if (!ctx) {
+                        gf_log (this->name, GF_LOG_ERROR, "Failed to "
+                                "get op_ctx");
+                        ret = -1;
+                        goto out;
                 }
-	}
+        }
         ret = rb_update_dstbrick_port (dst_brickinfo, rsp_dict,
                                        dict, replace_op);
         if (ret)
                 goto out;
 
-        switch (replace_op) {
-        case GF_REPLACE_OP_START:
-        {
-                ret = dict_get_str (dict, GF_REPLACE_BRICK_TID_KEY, &task_id_str);
-                if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "Missing replace-brick-id");
-                        ret = 0;
-                } else {
-                        gf_uuid_parse (task_id_str, volinfo->rep_brick.rb_id);
-                }
-
-                if (gf_is_local_addr (dst_brickinfo->hostname)) {
-                        gf_log (this->name, GF_LOG_INFO,
-                                "I AM THE DESTINATION HOST");
-                        if (!glusterd_is_rb_paused (volinfo)) {
-                                ret = rb_spawn_destination_brick
-                                        (volinfo, dst_brickinfo);
-                                if (ret) {
-                                        gf_log (this->name, GF_LOG_DEBUG,
-                                                "Failed to spawn destination "
-                                                "brick");
-                                        goto out;
-                                }
-                        } else {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "Replace brick is already started=> no "
-                                        "need to restart dst brick ");
-                        }
-		}
-
-
-		if (gf_is_local_addr (src_brickinfo->hostname)) {
-		        ret = rb_src_brick_restart (volinfo, src_brickinfo,
-				                    1);
-		        if (ret) {
-				gf_log (this->name, GF_LOG_DEBUG,
-	                                "Could not restart src-brick");
-			        goto out;
-			}
-		}
-
-		if (gf_is_local_addr (dst_brickinfo->hostname)) {
-			gf_log (this->name, GF_LOG_INFO,
-				"adding dst-brick port no");
-
-                        ret = rb_update_dstbrick_port (dst_brickinfo, rsp_dict,
-                                                       dict, replace_op);
-                        if (ret)
-                                goto out;
-                }
-
-                glusterd_set_rb_status (volinfo, GF_RB_STATUS_STARTED);
-		break;
-	}
-
-        case GF_REPLACE_OP_COMMIT:
-        {
-                ctx = glusterd_op_get_ctx ();
-                if (ctx) {
-                        ret = rb_do_operation (volinfo, src_brickinfo,
-                                               dst_brickinfo,
-                                               GF_REPLACE_OP_COMMIT);
-                        if (ret) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "Commit operation failed");
-                                goto out;
-                        }
-                }
+        if (strcmp(replace_op, "GF_REPLACE_OP_COMMIT_FORCE")) {
+                ret = -1;
+                goto out;
         }
-                /* fall through */
-        case GF_REPLACE_OP_COMMIT_FORCE:
-        {
-                if (gf_is_local_addr (dst_brickinfo->hostname)) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "I AM THE DESTINATION HOST");
-                        ret = rb_kill_destination_brick (volinfo,
-                                                         dst_brickinfo);
-                        if (ret) {
-                                gf_log (this->name, GF_LOG_CRITICAL,
-                                        "Unable to cleanup dst brick");
-                                goto out;
-                        }
-                }
 
-                ret = glusterd_svcs_stop (volinfo);
+        if (gf_is_local_addr (dst_brickinfo->hostname)) {
+                gf_log (this->name, GF_LOG_DEBUG, "I AM THE DESTINATION HOST");
+                ret = rb_kill_destination_brick (volinfo, dst_brickinfo);
                 if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "Unable to stop nfs server, ret: %d", ret);
-                }
-
-		ret = glusterd_op_perform_replace_brick (volinfo, src_brick,
-							 dst_brick, dict);
-		if (ret) {
-			gf_log (this->name, GF_LOG_CRITICAL, "Unable to add "
-				"dst-brick: %s to volume: %s", dst_brick,
-                                volinfo->volname);
-		        (void) glusterd_svcs_manager (volinfo);
-			goto out;
-		}
-
-		volinfo->rebal.defrag_status = 0;
-
-		ret = glusterd_svcs_manager (volinfo);
-		if (ret) {
                         gf_log (this->name, GF_LOG_CRITICAL,
-                                "Failed to generate nfs volume file");
-		}
-
-
-		ret = glusterd_fetchspec_notify (THIS);
-                glusterd_set_rb_status (volinfo, GF_RB_STATUS_NONE);
-                glusterd_brickinfo_delete (volinfo->rep_brick.dst_brick);
-                volinfo->rep_brick.src_brick = NULL;
-                volinfo->rep_brick.dst_brick = NULL;
-                gf_uuid_clear (volinfo->rep_brick.rb_id);
-        }
-        break;
-
-        case GF_REPLACE_OP_PAUSE:
-        {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "Received pause - doing nothing");
-                ctx = glusterd_op_get_ctx ();
-                if (ctx) {
-                        ret = rb_do_operation (volinfo, src_brickinfo,
-                                               dst_brickinfo,
-                                               GF_REPLACE_OP_PAUSE);
-                        if (ret) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "Pause operation failed");
-                                goto out;
-                        }
+                                "Unable to cleanup dst brick");
+                        goto out;
                 }
+        }
 
-                glusterd_set_rb_status (volinfo, GF_RB_STATUS_PAUSED);
+        ret = glusterd_svcs_stop (volinfo);
+        if (ret) {
+                gf_log (this->name, GF_LOG_ERROR,
+                        "Unable to stop nfs server, ret: %d", ret);
         }
-                break;
 
-        case GF_REPLACE_OP_ABORT:
-        {
+        ret = glusterd_op_perform_replace_brick (volinfo, src_brick,
+                                                 dst_brick, dict);
+        if (ret) {
+                gf_log (this->name, GF_LOG_CRITICAL, "Unable to add dst-brick: "
+                        "%s to volume: %s", dst_brick, volinfo->volname);
+		(void) glusterd_svcs_manager (volinfo);
+                goto out;
+        }
 
-                ctx = glusterd_op_get_ctx ();
-                if (ctx) {
-                        ret = rb_do_operation (volinfo, src_brickinfo,
-                                               dst_brickinfo,
-                                               GF_REPLACE_OP_ABORT);
-                        if (ret) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "Abort operation failed");
-                                goto out;
-                        }
-                }
+        volinfo->rebal.defrag_status = 0;
 
-                if (gf_is_local_addr (src_brickinfo->hostname)) {
-                        ret = rb_src_brick_restart (volinfo, src_brickinfo,
-                                                    0);
-                        if (ret) {
-                                gf_log (this->name, GF_LOG_ERROR,
-                                        "Couldn't restart src brick "
-                                        "with pump xlator disabled.");
-                                goto out;
-                        }
-                }
-
-                if (gf_is_local_addr (dst_brickinfo->hostname)) {
-                        gf_log (this->name, GF_LOG_INFO,
-                                "I AM THE DESTINATION HOST");
-                        ret = rb_kill_destination_brick (volinfo, dst_brickinfo);
-                        if (ret) {
-                                gf_log ("", GF_LOG_DEBUG,
-                                        "Failed to kill destination brick");
-                                goto out;
-                        }
-                }
-                glusterd_set_rb_status (volinfo, GF_RB_STATUS_NONE);
-                glusterd_brickinfo_delete (volinfo->rep_brick.dst_brick);
-                volinfo->rep_brick.src_brick = NULL;
-                volinfo->rep_brick.dst_brick = NULL;
+        ret = glusterd_svcs_manager (volinfo);
+        if (ret) {
+                gf_log (this->name, GF_LOG_CRITICAL,
+                        "Failed to generate nfs volume file");
         }
-        break;
-
-        case GF_REPLACE_OP_STATUS:
-        {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "received status - doing nothing");
-                ctx = glusterd_op_get_ctx ();
-                if (ctx) {
-                        if (glusterd_is_rb_paused (volinfo)) {
-                                ret = dict_set_str (ctx, "status-reply",
-                                                 "replace brick has been paused");
-                                if (ret)
-                                        gf_log (this->name, GF_LOG_ERROR,
-                                                "failed to set pump status"
-                                                " in ctx");
-                                goto out;
-                        }
 
-                        ret = rb_do_operation (volinfo, src_brickinfo,
-                                               dst_brickinfo,
-                                               GF_REPLACE_OP_STATUS);
-                        if (ret)
-                                goto out;
-                }
 
-        }
-                break;
+        ret = glusterd_fetchspec_notify (THIS);
+        glusterd_brickinfo_delete (volinfo->rep_brick.dst_brick);
+        volinfo->rep_brick.src_brick = NULL;
+        volinfo->rep_brick.dst_brick = NULL;
 
-        default:
-                ret = -1;
-                goto out;
-        }
-        if (!ret && replace_op != GF_REPLACE_OP_STATUS)
+        if (!ret)
 		ret = glusterd_store_volinfo (volinfo,
                                               GLUSTERD_VOLINFO_VER_AC_INCREMENT);
         if (ret)
@@ -1927,7 +805,6 @@ void
 glusterd_do_replace_brick (void *data)
 {
         glusterd_volinfo_t     *volinfo = NULL;
-        int32_t                 op      = 0;
         int32_t                 src_port = 0;
         int32_t                 dst_port = 0;
         int32_t                 ret      = 0;
@@ -1957,26 +834,20 @@ glusterd_do_replace_brick (void *data)
                         "Cancelling timer thread");
 	}
 
-        gf_log ("", GF_LOG_DEBUG,
+        gf_log (this->name, GF_LOG_DEBUG,
                 "Replace brick operation detected");
 
         ret = dict_get_bin (dict, "transaction_id", (void **)&txn_id);
         gf_log (this->name, GF_LOG_DEBUG, "transaction ID = %s",
                 uuid_utoa (*txn_id));
 
-        ret = dict_get_int32 (dict, "operation", &op);
-        if (ret) {
-                gf_log ("", GF_LOG_DEBUG,
-                        "dict_get on operation failed");
-                goto out;
-        }
         ret = dict_get_str (dict, "src-brick", &src_brick);
         if (ret) {
                 gf_log ("", GF_LOG_ERROR, "Unable to get src brick");
                 goto out;
         }
 
-        gf_log ("", GF_LOG_DEBUG,
+        gf_log (this->name, GF_LOG_DEBUG,
                 "src brick=%s", src_brick);
 
         ret = dict_get_str (dict, "dst-brick", &dst_brick);
@@ -1985,78 +856,52 @@ glusterd_do_replace_brick (void *data)
                 goto out;
         }
 
-        gf_log ("", GF_LOG_DEBUG,
+        gf_log (this->name, GF_LOG_DEBUG,
                 "dst brick=%s", dst_brick);
 
-        ret = dict_get_str (dict, "volname", &volname);
-
-        if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Unable to get volume name");
-                goto out;
-        }
-
         ret = glusterd_volinfo_find (volname, &volinfo);
         if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Unable to allocate memory");
+                gf_log (this->name, GF_LOG_ERROR, "Unable to find volinfo");
                 goto out;
         }
 
         ret = glusterd_volume_brickinfo_get_by_brick (src_brick, volinfo,
                                                       &src_brickinfo);
         if (ret) {
-                gf_log ("", GF_LOG_DEBUG, "Unable to get src-brickinfo");
+                gf_log (this->name, GF_LOG_DEBUG, "Unable to get "
+                        "src-brickinfo");
                 goto out;
         }
 
         ret = glusterd_get_rb_dst_brickinfo (volinfo, &dst_brickinfo);
         if (!dst_brickinfo) {
-                gf_log ("", GF_LOG_DEBUG, "Unable to get dst-brickinfo");
+                gf_log (this->name, GF_LOG_DEBUG, "Unable to get "
+                        "dst-brickinfo");
                 goto out;
         }
 
         ret = glusterd_resolve_brick (dst_brickinfo);
         if (ret) {
-                gf_log ("", GF_LOG_DEBUG, "Unable to resolve dst-brickinfo");
+                gf_log (this->name, GF_LOG_DEBUG, "Unable to resolve "
+                        "dst-brickinfo");
                 goto out;
         }
 
         ret = dict_get_int32 (dict, "src-brick-port", &src_port);
         if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Unable to get src-brick port");
+                gf_log (this->name, GF_LOG_ERROR, "Unable to get "
+                        "src-brick port");
                 goto out;
         }
 
         ret = dict_get_int32 (dict, "dst-brick-port", &dst_port);
         if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Unable to get dst-brick port");
+                gf_log (this->name, GF_LOG_ERROR, "Unable to get dst-brick port");
         }
 
         dst_brickinfo->port = dst_port;
         src_brickinfo->port = src_port;
 
-        switch (op) {
-        case GF_REPLACE_OP_START:
-                if (!dst_port) {
-                        ret = -1;
-                        goto out;
-                }
-
-                ret = rb_do_operation (volinfo, src_brickinfo, dst_brickinfo,
-                                       GF_REPLACE_OP_START);
-                if (ret)
-                        goto out;
-                break;
-        case GF_REPLACE_OP_PAUSE:
-        case GF_REPLACE_OP_ABORT:
-        case GF_REPLACE_OP_COMMIT:
-        case GF_REPLACE_OP_COMMIT_FORCE:
-        case GF_REPLACE_OP_STATUS:
-                break;
-        default:
-                ret = -1;
-                goto out;
-        }
-
 out:
         if (ret)
                 ret = glusterd_op_sm_inject_event (GD_OP_EVENT_RCVD_RJT,
diff --git a/xlators/mgmt/glusterd/src/glusterd-store.c b/xlators/mgmt/glusterd/src/glusterd-store.c
index 0beae3e8bbf..f6e31b24943 100644
--- a/xlators/mgmt/glusterd/src/glusterd-store.c
+++ b/xlators/mgmt/glusterd/src/glusterd-store.c
@@ -1103,21 +1103,6 @@ out:
 }
 
 static void
-glusterd_store_rbstatepath_set (glusterd_volinfo_t *volinfo, char *rbstatepath,
-                                size_t len)
-{
-        char    voldirpath[PATH_MAX] = {0,};
-        GF_ASSERT (volinfo);
-        GF_ASSERT (rbstatepath);
-        GF_ASSERT (len <= PATH_MAX);
-
-        glusterd_store_voldirpath_set (volinfo, voldirpath,
-                                       sizeof (voldirpath));
-        snprintf (rbstatepath, len, "%s/%s", voldirpath,
-                  GLUSTERD_VOLUME_RBSTATE_FILE);
-}
-
-static void
 glusterd_store_volfpath_set (glusterd_volinfo_t *volinfo, char *volfpath,
                              size_t len)
 {
@@ -1192,20 +1177,6 @@ glusterd_store_snapfpath_set (glusterd_snap_t *snap, char *snap_fpath,
 }
 
 int32_t
-glusterd_store_create_rbstate_shandle_on_absence (glusterd_volinfo_t *volinfo)
-{
-        char            rbstatepath[PATH_MAX] = {0};
-        int32_t         ret                   = 0;
-
-        GF_ASSERT (volinfo);
-
-        glusterd_store_rbstatepath_set (volinfo, rbstatepath, sizeof (rbstatepath));
-        ret = gf_store_handle_create_on_absence (&volinfo->rb_shandle,
-                                                 rbstatepath);
-        return ret;
-}
-
-int32_t
 glusterd_store_create_vol_shandle_on_absence (glusterd_volinfo_t *volinfo)
 {
         char            volfpath[PATH_MAX] = {0};
@@ -1309,93 +1280,6 @@ out:
         return ret;
 }
 
-int32_t
-glusterd_store_rbstate_write (int fd, glusterd_volinfo_t *volinfo)
-{
-        int     ret             = -1;
-        int     port            = 0;
-        char    buf[PATH_MAX]   = {0, };
-
-        GF_ASSERT (fd > 0);
-        GF_ASSERT (volinfo);
-
-        snprintf (buf, sizeof (buf), "%d", volinfo->rep_brick.rb_status);
-        ret = gf_store_save_value (fd, GLUSTERD_STORE_KEY_RB_STATUS, buf);
-        if (ret)
-                goto out;
-
-        if (volinfo->rep_brick.rb_status > GF_RB_STATUS_NONE) {
-
-                snprintf (buf, sizeof (buf), "%s:%s",
-                          volinfo->rep_brick.src_brick->hostname,
-                          volinfo->rep_brick.src_brick->path);
-                ret = gf_store_save_value (fd, GLUSTERD_STORE_KEY_RB_SRC_BRICK,
-                                           buf);
-                if (ret)
-                        goto out;
-
-                snprintf (buf, sizeof (buf), "%s:%s",
-                          volinfo->rep_brick.dst_brick->hostname,
-                          volinfo->rep_brick.dst_brick->path);
-                ret = gf_store_save_value (fd, GLUSTERD_STORE_KEY_RB_DST_BRICK,
-                                           buf);
-                if (ret)
-                        goto out;
-
-                switch (volinfo->transport_type) {
-                        case GF_TRANSPORT_RDMA:
-                                port = volinfo->rep_brick.dst_brick->rdma_port;
-                                break;
-
-                        case GF_TRANSPORT_TCP:
-                        case GF_TRANSPORT_BOTH_TCP_RDMA:
-                                port = volinfo->rep_brick.dst_brick->port;
-                                break;
-                }
-
-                snprintf (buf, sizeof (buf), "%d", port);
-                ret = gf_store_save_value (fd, GLUSTERD_STORE_KEY_RB_DST_PORT,
-                                           buf);
-                if (ret)
-                        goto out;
-                gf_uuid_unparse (volinfo->rep_brick.rb_id, buf);
-                ret = gf_store_save_value (fd, GF_REPLACE_BRICK_TID_KEY, buf);
-        }
-
-        ret = 0;
-out:
-        gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
-}
-
-int32_t
-glusterd_store_perform_rbstate_store (glusterd_volinfo_t *volinfo)
-{
-        int                         fd = -1;
-        int32_t                     ret = -1;
-        GF_ASSERT (volinfo);
-
-        fd = gf_store_mkstemp (volinfo->rb_shandle);
-        if (fd <= 0) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = glusterd_store_rbstate_write (fd, volinfo);
-        if (ret)
-                goto out;
-
-        ret = gf_store_rename_tmppath (volinfo->rb_shandle);
-        if (ret)
-                goto out;
-
-out:
-        if (ret && (fd > 0))
-                gf_store_unlink_tmppath (volinfo->rb_shandle);
-        gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret);
-        return ret;
-}
-
 int
 _gd_store_rebalance_dict (dict_t *dict, char *key, data_t *value, void *data)
 {
@@ -1549,8 +1433,6 @@ glusterd_store_volume_cleanup_tmp (glusterd_volinfo_t *volinfo)
 
         gf_store_unlink_tmppath (volinfo->shandle);
 
-        gf_store_unlink_tmppath (volinfo->rb_shandle);
-
         gf_store_unlink_tmppath (volinfo->node_state_shandle);
 
         gf_store_unlink_tmppath (volinfo->snapd.handle);
@@ -1676,10 +1558,6 @@ glusterd_store_volinfo (glusterd_volinfo_t *volinfo, glusterd_volinfo_ver_ac_t a
         if (ret)
                 goto out;
 
-        ret = glusterd_store_create_rbstate_shandle_on_absence (volinfo);
-        if (ret)
-                goto out;
-
         ret = glusterd_store_create_nodestate_sh_on_absence (volinfo);
         if (ret)
                 goto out;
@@ -1695,10 +1573,6 @@ glusterd_store_volinfo (glusterd_volinfo_t *volinfo, glusterd_volinfo_ver_ac_t a
                 goto out;
         }
 
-        ret = glusterd_store_perform_rbstate_store (volinfo);
-        if (ret)
-                goto out;
-
         ret = glusterd_store_perform_node_state_store (volinfo);
         if (ret)
                 goto out;
@@ -2445,106 +2319,6 @@ out:
         return ret;
 }
 
-
-int32_t
-glusterd_store_retrieve_rbstate (glusterd_volinfo_t *volinfo)
-{
-        int32_t                   ret                   = -1;
-        gf_store_iter_t           *iter                 = NULL;
-        char                      *key                  = NULL;
-        char                      *value                = NULL;
-        char                      volpath[PATH_MAX]     = {0,};
-        glusterd_conf_t           *priv                 = NULL;
-        char                      path[PATH_MAX]        = {0,};
-        gf_store_op_errno_t       op_errno              = GD_STORE_SUCCESS;
-        xlator_t                 *this                  = NULL;
-
-        this = THIS;
-        GF_ASSERT (this);
-        priv = this->private;
-        GF_ASSERT (priv);
-        GF_ASSERT (volinfo);
-
-        GLUSTERD_GET_VOLUME_DIR(volpath, volinfo, priv);
-        snprintf (path, sizeof (path), "%s/%s", volpath,
-                  GLUSTERD_VOLUME_RBSTATE_FILE);
-
-        ret = gf_store_handle_retrieve (path, &volinfo->rb_shandle);
-
-        if (ret)
-                goto out;
-
-        ret = gf_store_iter_new (volinfo->rb_shandle, &iter);
-
-        if (ret)
-                goto out;
-
-        ret = gf_store_iter_get_next (iter, &key, &value, &op_errno);
-        if (ret)
-                goto out;
-
-        while (!ret) {
-                if (!strncmp (key, GLUSTERD_STORE_KEY_RB_STATUS,
-                              strlen (GLUSTERD_STORE_KEY_RB_STATUS))) {
-                        volinfo->rep_brick.rb_status = atoi (value);
-                }
-
-                if (volinfo->rep_brick.rb_status > GF_RB_STATUS_NONE) {
-                        if (!strncmp (key, GLUSTERD_STORE_KEY_RB_SRC_BRICK,
-                                      strlen (GLUSTERD_STORE_KEY_RB_SRC_BRICK))) {
-                                ret = glusterd_brickinfo_new_from_brick (value,
-                                                &volinfo->rep_brick.src_brick);
-                                if (ret)
-                                        goto out;
-                        } else if (!strncmp (key, GLUSTERD_STORE_KEY_RB_DST_BRICK,
-                                             strlen (GLUSTERD_STORE_KEY_RB_DST_BRICK))) {
-                                ret = glusterd_brickinfo_new_from_brick (value,
-                                                &volinfo->rep_brick.dst_brick);
-                                if (ret)
-                                        goto out;
-                        } else if (!strncmp (key, GLUSTERD_STORE_KEY_RB_DST_PORT,
-                                             strlen (GLUSTERD_STORE_KEY_RB_DST_PORT))) {
-                                switch (volinfo->transport_type) {
-                                case GF_TRANSPORT_RDMA:
-                                volinfo->rep_brick.dst_brick->rdma_port =
-                                                 atoi (value);
-                                        break;
-
-                                case GF_TRANSPORT_TCP:
-                                case GF_TRANSPORT_BOTH_TCP_RDMA:
-                                volinfo->rep_brick.dst_brick->port =
-                                                atoi (value);
-                                        break;
-                                }
-                        } else if (!strncmp (key, GF_REPLACE_BRICK_TID_KEY,
-                                             strlen (GF_REPLACE_BRICK_TID_KEY))) {
-                                        gf_uuid_parse (value,
-                                                    volinfo->rep_brick.rb_id);
-                        }
-                }
-
-                GF_FREE (key);
-                GF_FREE (value);
-                key = NULL;
-                value = NULL;
-
-                ret = gf_store_iter_get_next (iter, &key, &value, &op_errno);
-        }
-
-        if (op_errno != GD_STORE_EOF)
-                goto out;
-
-        ret = gf_store_iter_destroy (iter);
-
-        if (ret)
-                goto out;
-
-out:
-        gf_log (this->name, GF_LOG_TRACE, "Returning with %d", ret);
-
-        return ret;
-}
-
 int32_t
 glusterd_store_retrieve_node_state (glusterd_volinfo_t *volinfo)
 {
@@ -3161,15 +2935,6 @@ glusterd_store_retrieve_volumes (xlator_t  *this, glusterd_snap_t *snap)
                         goto out;
                 }
 
-                ret = glusterd_store_retrieve_rbstate (volinfo);
-                if (ret) {
-                        /* Backward compatibility */
-                        gf_log ("", GF_LOG_INFO, "Creating a new rbstate "
-                                "for volume: %s.", entry->d_name);
-                        ret = glusterd_store_create_rbstate_shandle_on_absence (volinfo);
-                        ret = glusterd_store_perform_rbstate_store (volinfo);
-                }
-
                 ret = glusterd_store_retrieve_node_state (volinfo);
                 if (ret) {
                         /* Backward compatibility */
diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.c b/xlators/mgmt/glusterd/src/glusterd-utils.c
index 40248d34614..8209e779c52 100644
--- a/xlators/mgmt/glusterd/src/glusterd-utils.c
+++ b/xlators/mgmt/glusterd/src/glusterd-utils.c
@@ -2249,48 +2249,6 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo,
                         goto out;
         }
 
-        memset (key, 0, sizeof (key));
-        snprintf (key, 256, "%s%d."GLUSTERD_STORE_KEY_RB_STATUS, prefix, count);
-        ret = dict_set_int32 (dict, key, volinfo->rep_brick.rb_status);
-        if (ret)
-                goto out;
-
-        if (volinfo->rep_brick.rb_status > GF_RB_STATUS_NONE) {
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, 256, "%s%d."GLUSTERD_STORE_KEY_RB_SRC_BRICK,
-                          prefix, count);
-                gf_asprintf (&src_brick, "%s:%s",
-                             volinfo->rep_brick.src_brick->hostname,
-                             volinfo->rep_brick.src_brick->path);
-                ret = dict_set_dynstr (dict, key, src_brick);
-                if (ret)
-                        goto out;
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, 256, "%s%d."GLUSTERD_STORE_KEY_RB_DST_BRICK,
-                          prefix, count);
-                gf_asprintf (&dst_brick, "%s:%s",
-                             volinfo->rep_brick.dst_brick->hostname,
-                             volinfo->rep_brick.dst_brick->path);
-                ret = dict_set_dynstr (dict, key, dst_brick);
-                if (ret)
-                        goto out;
-
-                rb_id_str = gf_strdup (uuid_utoa (volinfo->rep_brick.rb_id));
-                if (!rb_id_str) {
-                        ret = -1;
-                        goto out;
-                }
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s%d.rb_id", prefix, count);
-                ret = dict_set_dynstr (dict, key, rb_id_str);
-                if (ret)
-                        goto out;
-                rb_id_str = NULL;
-        }
-
         snprintf (pfx, sizeof (pfx), "%s%d", prefix, count);
         ctx.dict = dict;
         ctx.prefix = pfx;
@@ -3300,58 +3258,6 @@ glusterd_import_volinfo (dict_t *peer_data, int count,
         }
 
         memset (key, 0, sizeof (key));
-        snprintf (key, 256, "%s%d."GLUSTERD_STORE_KEY_RB_STATUS, prefix, count);
-        ret = dict_get_int32 (peer_data, key, &rb_status);
-        if (ret)
-                goto out;
-        new_volinfo->rep_brick.rb_status = rb_status;
-
-        if (new_volinfo->rep_brick.rb_status > GF_RB_STATUS_NONE) {
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, 256, "%s%d."GLUSTERD_STORE_KEY_RB_SRC_BRICK,
-                          prefix, count);
-                ret = dict_get_str (peer_data, key, &src_brick);
-                if (ret)
-                        goto out;
-
-                ret = glusterd_brickinfo_new_from_brick (src_brick,
-                                        &new_volinfo->rep_brick.src_brick);
-                if (ret) {
-                        gf_log ("", GF_LOG_ERROR, "Unable to create"
-                                " src brickinfo");
-                        goto out;
-                }
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, 256, "%s%d."GLUSTERD_STORE_KEY_RB_DST_BRICK,
-                          prefix, count);
-                ret = dict_get_str (peer_data, key, &dst_brick);
-                if (ret)
-                        goto out;
-
-                ret = glusterd_brickinfo_new_from_brick (dst_brick,
-                                     &new_volinfo->rep_brick.dst_brick);
-                if (ret) {
-                        gf_log ("", GF_LOG_ERROR, "Unable to create"
-                                " dst brickinfo");
-                        goto out;
-                }
-
-                memset (key, 0, sizeof (key));
-                snprintf (key, sizeof (key), "%s%d.rb_id", prefix, count);
-                ret = dict_get_str (peer_data, key, &rb_id_str);
-                if (ret) {
-                        /* This is not present in older glusterfs versions,
-                         * so don't error out
-                         */
-                        ret = 0;
-                } else {
-                        gf_uuid_parse (rb_id_str, new_volinfo->rep_brick.rb_id);
-                }
-        }
-
-        memset (key, 0, sizeof (key));
         snprintf (key, sizeof (key), "%s%d", prefix, count);
         ret = gd_import_volume_snap_details (peer_data, new_volinfo, key,
                                              volname);
@@ -5256,20 +5162,6 @@ glusterd_is_defrag_on (glusterd_volinfo_t *volinfo)
         return (volinfo->rebal.defrag != NULL);
 }
 
-gf_boolean_t
-glusterd_is_rb_ongoing (glusterd_volinfo_t *volinfo)
-{
-        gf_boolean_t     ret = _gf_false;
-
-        GF_ASSERT (volinfo);
-
-        if (glusterd_is_rb_started (volinfo) ||
-            glusterd_is_rb_paused (volinfo))
-                ret = _gf_true;
-
-        return ret;
-}
-
 int
 glusterd_new_brick_validate (char *brick, glusterd_brickinfo_t *brickinfo,
                              char *op_errstr, size_t len)
@@ -5352,36 +5244,6 @@ out:
         return ret;
 }
 
-int
-glusterd_is_rb_started(glusterd_volinfo_t *volinfo)
-{
-        gf_log ("", GF_LOG_DEBUG,
-                "is_rb_started:status=%d", volinfo->rep_brick.rb_status);
-        return (volinfo->rep_brick.rb_status == GF_RB_STATUS_STARTED);
-
-}
-
-int
-glusterd_is_rb_paused ( glusterd_volinfo_t *volinfo)
-{
-        gf_log ("", GF_LOG_DEBUG,
-                "is_rb_paused:status=%d", volinfo->rep_brick.rb_status);
-
-        return (volinfo->rep_brick.rb_status == GF_RB_STATUS_PAUSED);
-}
-
-inline int
-glusterd_set_rb_status (glusterd_volinfo_t *volinfo, gf_rb_status_t status)
-{
-        gf_log ("", GF_LOG_DEBUG,
-                "setting status from %d to %d",
-                volinfo->rep_brick.rb_status,
-                status);
-
-        volinfo->rep_brick.rb_status = status;
-        return 0;
-}
-
 inline int
 glusterd_rb_check_bricks (glusterd_volinfo_t *volinfo,
                           glusterd_brickinfo_t *src, glusterd_brickinfo_t *dst)
diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.h b/xlators/mgmt/glusterd/src/glusterd-utils.h
index 15bbf2268f7..fcfddd5bffa 100644
--- a/xlators/mgmt/glusterd/src/glusterd-utils.h
+++ b/xlators/mgmt/glusterd/src/glusterd-utils.h
@@ -242,17 +242,7 @@ glusterd_volume_brickinfo_get (uuid_t uuid, char *hostname, char *path,
 int
 glusterd_brickinfo_get (uuid_t uuid, char *hostname, char *path,
                        glusterd_brickinfo_t **brickinfo);
-int
-glusterd_is_rb_started (glusterd_volinfo_t *volinfo);
-
-int
-glusterd_is_rb_paused (glusterd_volinfo_t *volinfo);
 
-int
-glusterd_set_rb_status (glusterd_volinfo_t *volinfo, gf_rb_status_t status);
-
-gf_boolean_t
-glusterd_is_rb_ongoing (glusterd_volinfo_t *volinfo);
 
 int
 glusterd_rb_check_bricks (glusterd_volinfo_t *volinfo,
diff --git a/xlators/mgmt/glusterd/src/glusterd-volume-ops.c b/xlators/mgmt/glusterd/src/glusterd-volume-ops.c
index 3c3e6e01d8e..1d29d50e13e 100644
--- a/xlators/mgmt/glusterd/src/glusterd-volume-ops.c
+++ b/xlators/mgmt/glusterd/src/glusterd-volume-ops.c
@@ -1516,16 +1516,6 @@ glusterd_op_stage_stop_volume (dict_t *dict, char **op_errstr)
                 }
         }
 
-        if (glusterd_is_rb_ongoing (volinfo)) {
-                snprintf (msg, sizeof (msg), "Replace brick is in progress on "
-                          "volume %s. Please retry after replace-brick "
-                          "operation is committed or aborted", volname);
-                gf_log (this->name, GF_LOG_WARNING, "replace-brick in progress "
-                        "on volume %s", volname);
-                ret = -1;
-                goto out;
-        }
-
         if (glusterd_is_defrag_on (volinfo)) {
                 snprintf (msg, sizeof(msg), "rebalance session is "
                           "in progress for the volume '%s'", volname);
@@ -1533,14 +1523,6 @@ glusterd_op_stage_stop_volume (dict_t *dict, char **op_errstr)
                 ret = -1;
                 goto out;
         }
-        if (volinfo->rep_brick.rb_status != GF_RB_STATUS_NONE) {
-                snprintf (msg, sizeof(msg), "replace-brick session is "
-                          "in progress for the volume '%s'", volname);
-                gf_log (this->name, GF_LOG_WARNING, "%s", msg);
-                ret = -1;
-                goto out;
-        }
-
 out:
         if (msg[0] != 0)
                 *op_errstr = gf_strdup (msg);
diff --git a/xlators/mgmt/glusterd/src/glusterd.h b/xlators/mgmt/glusterd/src/glusterd.h
index 5ad92a47177..812a4434415 100644
--- a/xlators/mgmt/glusterd/src/glusterd.h
+++ b/xlators/mgmt/glusterd/src/glusterd.h
@@ -291,10 +291,8 @@ struct glusterd_rebalance_ {
 typedef struct glusterd_rebalance_ glusterd_rebalance_t;
 
 struct glusterd_replace_brick_ {
-        gf_rb_status_t          rb_status;
         glusterd_brickinfo_t   *src_brick;
         glusterd_brickinfo_t   *dst_brick;
-        uuid_t                  rb_id;
 };
 
 typedef struct glusterd_replace_brick_ glusterd_replace_brick_t;
@@ -361,7 +359,6 @@ struct glusterd_volinfo_ {
                                                     distribute subvolume */
         int                       port;
         gf_store_handle_t        *shandle;
-        gf_store_handle_t        *rb_shandle;
         gf_store_handle_t        *node_state_shandle;
         gf_store_handle_t        *quota_conf_shandle;