From 0ef62933649392051e73fe01c028e41baddec489 Mon Sep 17 00:00:00 2001 From: Mohammed Rafi KC Date: Tue, 8 Sep 2015 13:04:45 +0530 Subject: tier/shd: make shd commands compatible with tiering tiering volfiles may contain afr and disperse together or multiple time based on configuration. And the informations for those configurations are stored in tier_info. So most of the volgen code generation need to be changed to make compatible with it. Change-Id: I563d1ca6f281f59090ebd470b7fda1cc4b1b7e1d BUG: 1261276 Signed-off-by: Mohammed Rafi KC Reviewed-on: http://review.gluster.org/12135 Tested-by: NetBSD Build System Tested-by: Gluster Build System Reviewed-by: Pranith Kumar Karampuri --- xlators/mgmt/glusterd/src/glusterd-op-sm.c | 243 +++++++++++++++--------- xlators/mgmt/glusterd/src/glusterd-utils.c | 18 +- xlators/mgmt/glusterd/src/glusterd-volgen.c | 91 +++++++-- xlators/mgmt/glusterd/src/glusterd-volgen.h | 5 +- xlators/mgmt/glusterd/src/glusterd-volume-ops.c | 90 +++++++-- xlators/mgmt/glusterd/src/glusterd-volume-set.c | 10 + 6 files changed, 331 insertions(+), 126 deletions(-) (limited to 'xlators') diff --git a/xlators/mgmt/glusterd/src/glusterd-op-sm.c b/xlators/mgmt/glusterd/src/glusterd-op-sm.c index 01e0658e52a..0ff2d478ef1 100644 --- a/xlators/mgmt/glusterd/src/glusterd-op-sm.c +++ b/xlators/mgmt/glusterd/src/glusterd-op-sm.c @@ -1538,7 +1538,6 @@ glusterd_op_stage_status_volume (dict_t *dict, char **op_errstr) char msg[2048] = {0,}; char *volname = NULL; char *brick = NULL; - char *shd_key = NULL; xlator_t *this = NULL; glusterd_conf_t *priv = NULL; glusterd_brickinfo_t *brickinfo = NULL; @@ -1619,10 +1618,7 @@ glusterd_op_stage_status_volume (dict_t *dict, char **op_errstr) } } else if ((cmd & GF_CLI_STATUS_SHD) != 0) { if (glusterd_is_shd_compatible_volume (volinfo)) { - shd_key = volgen_get_shd_key(volinfo); - shd_enabled = dict_get_str_boolean (vol_opts, - shd_key, - _gf_true); + shd_enabled = is_self_heal_enabled (volinfo, vol_opts); } else { ret = -1; snprintf (msg, sizeof (msg), @@ -3077,7 +3073,6 @@ glusterd_op_status_volume (dict_t *dict, char **op_errstr, uint32_t cmd = 0; char *volname = NULL; char *brick = NULL; - char *shd_key = NULL; xlator_t *this = NULL; glusterd_volinfo_t *volinfo = NULL; glusterd_brickinfo_t *brickinfo = NULL; @@ -3250,12 +3245,9 @@ glusterd_op_status_volume (dict_t *dict, char **op_errstr, other_count++; node_count++; } - if (glusterd_is_shd_compatible_volume (volinfo)) { - shd_key = volgen_get_shd_key (volinfo); - shd_enabled = dict_get_str_boolean (vol_opts, - shd_key, - _gf_true); - } + + if (glusterd_is_shd_compatible_volume (volinfo)) + shd_enabled = is_self_heal_enabled (volinfo, vol_opts); if (shd_enabled) { ret = glusterd_add_node_to_dict (priv->shd_svc.name, rsp_dict, @@ -6055,13 +6047,13 @@ out: int _select_hxlator_with_matching_brick (xlator_t *this, - glusterd_volinfo_t *volinfo, dict_t *dict) + glusterd_volinfo_t *volinfo, dict_t *dict, + int *index) { char *hostname = NULL; char *path = NULL; glusterd_brickinfo_t *brickinfo = NULL; glusterd_conf_t *priv = NULL; - int index = 1; int hxl_children = 0; priv = this->private; @@ -6071,6 +6063,8 @@ _select_hxlator_with_matching_brick (xlator_t *this, return -1; hxl_children = _get_hxl_children_count (volinfo); + if ((*index) == 0) + (*index)++; cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) { if (gf_uuid_is_null (brickinfo->uuid)) @@ -6078,22 +6072,21 @@ _select_hxlator_with_matching_brick (xlator_t *this, if (!gf_uuid_compare (MY_UUID, brickinfo->uuid)) { _add_hxlator_to_dict (dict, volinfo, - (index - 1)/hxl_children, 0); + ((*index) - 1)/hxl_children, 0); return 1; } - index++; + (*index)++; } return 0; } -int +void _select_hxlators_with_local_bricks (xlator_t *this, glusterd_volinfo_t *volinfo, - dict_t *dict) + dict_t *dict, int *index, + int *hxlator_count) { glusterd_brickinfo_t *brickinfo = NULL; glusterd_conf_t *priv = NULL; - int index = 1; - int hxlator_count = 0; int hxl_children = 0; gf_boolean_t add = _gf_false; int cmd_replica_index = -1; @@ -6101,6 +6094,9 @@ _select_hxlators_with_local_bricks (xlator_t *this, glusterd_volinfo_t *volinfo, priv = this->private; hxl_children = _get_hxl_children_count (volinfo); + if ((*index) == 0) + (*index)++; + cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) { if (gf_uuid_is_null (brickinfo->uuid)) (void)glusterd_resolve_brick (brickinfo); @@ -6108,35 +6104,35 @@ _select_hxlators_with_local_bricks (xlator_t *this, glusterd_volinfo_t *volinfo, if (!gf_uuid_compare (MY_UUID, brickinfo->uuid)) add = _gf_true; - if (index % hxl_children == 0) { + if ((*index) % hxl_children == 0) { if (add) { - _add_hxlator_to_dict (dict, volinfo, - (index - 1)/hxl_children, - hxlator_count); - hxlator_count++; + _add_hxlator_to_dict (dict, volinfo, + ((*index) - 1)/hxl_children, + (*hxlator_count)); + (*hxlator_count)++; } add = _gf_false; } - index++; + (*index)++; } - return hxlator_count; } int _select_hxlators_for_full_self_heal (xlator_t *this, glusterd_volinfo_t *volinfo, - dict_t *dict) + dict_t *dict, int *index, + int *hxlator_count) { glusterd_brickinfo_t *brickinfo = NULL; glusterd_conf_t *priv = NULL; - int index = 1; - int hxlator_count = 0; int hxl_children = 0; uuid_t candidate = {0}; priv = this->private; + if ((*index) == 0) + (*index)++; if (volinfo->type == GF_CLUSTER_TYPE_DISPERSE) { hxl_children = volinfo->disperse_count; } else { @@ -6150,19 +6146,19 @@ _select_hxlators_for_full_self_heal (xlator_t *this, if (gf_uuid_compare (brickinfo->uuid, candidate) > 0) gf_uuid_copy (candidate, brickinfo->uuid); - if (index % hxl_children == 0) { + if ((*index) % hxl_children == 0) { if (!gf_uuid_compare (MY_UUID, candidate)) { _add_hxlator_to_dict (dict, volinfo, - (index-1)/hxl_children, - hxlator_count); - hxlator_count++; + ((*index)-1)/hxl_children, + (*hxlator_count)); + (*hxlator_count)++; } gf_uuid_clear (candidate); } - index++; + (*index)++; } - return hxlator_count; + return *hxlator_count; } @@ -6223,13 +6219,13 @@ out: static int fill_shd_status_for_local_bricks (dict_t *dict, glusterd_volinfo_t *volinfo, - cli_cmd_type type, dict_t *req_dict) + cli_cmd_type type, int *index, + dict_t *req_dict) { glusterd_brickinfo_t *brickinfo = NULL; char msg[1024] = {0,}; char key[1024] = {0,}; char value[1024] = {0,}; - int index = 0; int ret = 0; xlator_t *this = NULL; int cmd_replica_index = -1; @@ -6255,18 +6251,18 @@ fill_shd_status_for_local_bricks (dict_t *dict, glusterd_volinfo_t *volinfo, (void)glusterd_resolve_brick (brickinfo); if (gf_uuid_compare (MY_UUID, brickinfo->uuid)) { - index++; + (*index)++; continue; } if (type == PER_HEAL_XL) { - if (cmd_replica_index != (index/volinfo->replica_count)) { - index++; + if (cmd_replica_index != ((*index)/volinfo->replica_count)) { + (*index)++; continue; - } + } } - snprintf (key, sizeof (key), "%d-status",index); + snprintf (key, sizeof (key), "%d-status", (*index)); snprintf (value, sizeof (value), "%s %s",msg, uuid_utoa(MY_UUID)); ret = dict_set_dynstr (dict, key, gf_strdup(value)); @@ -6276,7 +6272,7 @@ fill_shd_status_for_local_bricks (dict_t *dict, glusterd_volinfo_t *volinfo, "set the dictionary for shd status msg"); goto out; } - snprintf (key, sizeof (key), "%d-shd-status",index); + snprintf (key, sizeof (key), "%d-shd-status", (*index)); ret = dict_set_str (dict, key, "off"); if (ret) { gf_msg (this->name, GF_LOG_ERROR, 0, @@ -6285,58 +6281,29 @@ fill_shd_status_for_local_bricks (dict_t *dict, glusterd_volinfo_t *volinfo, goto out; } - index++; + (*index)++; } out: return ret; } - -static int -glusterd_bricks_select_heal_volume (dict_t *dict, char **op_errstr, - struct cds_list_head *selected, - dict_t *rsp_dict) +int +glusterd_shd_select_brick_xlator (dict_t *dict, gf_xl_afr_op_t heal_op, + glusterd_volinfo_t *volinfo, int *index, + int *hxlator_count, dict_t *rsp_dict) { int ret = -1; - char *volname = NULL; glusterd_conf_t *priv = NULL; - glusterd_volinfo_t *volinfo = NULL; xlator_t *this = NULL; char msg[2048] = {0,}; glusterd_pending_node_t *pending_node = NULL; - gf_xl_afr_op_t heal_op = GF_SHD_OP_INVALID; - int hxlator_count = 0; this = THIS; GF_ASSERT (this); priv = this->private; GF_ASSERT (priv); - ret = dict_get_str (dict, "volname", &volname); - if (ret) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_DICT_GET_FAILED, "volume name get failed"); - goto out; - } - - ret = glusterd_volinfo_find (volname, &volinfo); - if (ret) { - snprintf (msg, sizeof (msg), "Volume %s does not exist", - volname); - - *op_errstr = gf_strdup (msg); - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_VOL_NOT_FOUND, "%s", msg); - goto out; - } - - ret = dict_get_int32 (dict, "heal-op", (int32_t*)&heal_op); - if (ret || (heal_op == GF_SHD_OP_INVALID)) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_DICT_GET_FAILED, "heal op invalid"); - goto out; - } switch (heal_op) { case GF_SHD_OP_INDEX_SUMMARY: @@ -6352,6 +6319,7 @@ glusterd_bricks_select_heal_volume (dict_t *dict, char **op_errstr, ret = fill_shd_status_for_local_bricks (rsp_dict, volinfo, ALL_HEAL_XL, + index, dict); if (ret) gf_msg (this->name, GF_LOG_ERROR, 0, @@ -6373,6 +6341,7 @@ glusterd_bricks_select_heal_volume (dict_t *dict, char **op_errstr, ret = fill_shd_status_for_local_bricks (rsp_dict, volinfo, PER_HEAL_XL, + index, dict); if (ret) gf_msg (this->name, GF_LOG_ERROR, 0, @@ -6391,35 +6360,104 @@ glusterd_bricks_select_heal_volume (dict_t *dict, char **op_errstr, switch (heal_op) { case GF_SHD_OP_HEAL_FULL: - hxlator_count = _select_hxlators_for_full_self_heal (this, - volinfo, - dict); + _select_hxlators_for_full_self_heal (this, volinfo, dict, + index, hxlator_count); break; case GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA: - hxlator_count = _select_hxlator_with_matching_brick (this, - volinfo, - dict); + (*hxlator_count) += _select_hxlator_with_matching_brick (this, + volinfo, + dict, + index); break; default: - hxlator_count = _select_hxlators_with_local_bricks (this, - volinfo, - dict); + _select_hxlators_with_local_bricks (this, volinfo, dict, + index, hxlator_count); break; } + ret = (*hxlator_count); +out: + return ret; +} - if (!hxlator_count) + +static int +glusterd_bricks_select_heal_volume (dict_t *dict, char **op_errstr, + struct cds_list_head *selected, + dict_t *rsp_dict) +{ + int ret = -1; + char *volname = NULL; + glusterd_conf_t *priv = NULL; + glusterd_volinfo_t *volinfo = NULL; + glusterd_volinfo_t *dup_volinfo = NULL; + xlator_t *this = NULL; + char msg[2048] = {0,}; + glusterd_pending_node_t *pending_node = NULL; + gf_xl_afr_op_t heal_op = GF_SHD_OP_INVALID; + int hxlator_count = 0; + int index = 0; + + this = THIS; + GF_ASSERT (this); + priv = this->private; + GF_ASSERT (priv); + + ret = dict_get_str (dict, "volname", &volname); + if (ret) { + gf_msg ("glusterd", GF_LOG_ERROR, 0, + GD_MSG_DICT_GET_FAILED, "volume name get failed"); goto out; - if (hxlator_count == -1) { - gf_msg (this->name, GF_LOG_ERROR, 0, - GD_MSG_XLATOR_COUNT_GET_FAIL, "Could not determine the" - "translator count"); - ret = -1; + } + + ret = glusterd_volinfo_find (volname, &volinfo); + if (ret) { + snprintf (msg, sizeof (msg), "Volume %s does not exist", + volname); + + *op_errstr = gf_strdup (msg); + gf_msg ("glusterd", GF_LOG_ERROR, 0, + GD_MSG_VOL_NOT_FOUND, "%s", msg); goto out; } - ret = dict_set_int32 (dict, "count", hxlator_count); - if (ret) + ret = dict_get_int32 (dict, "heal-op", (int32_t *)&heal_op); + if (ret || (heal_op == GF_SHD_OP_INVALID)) { + gf_msg ("glusterd", GF_LOG_ERROR, 0, + GD_MSG_DICT_GET_FAILED, "heal op invalid"); goto out; + } + if (volinfo->type == GF_CLUSTER_TYPE_TIER) { + ret = glusterd_create_sub_tier_volinfo (volinfo, &dup_volinfo, + _gf_false, volname); + if (ret < 0) + goto out; + + ret = glusterd_shd_select_brick_xlator (dict, heal_op, + dup_volinfo, + &index, &hxlator_count, + rsp_dict); + glusterd_volinfo_delete (dup_volinfo); + if (ret < 0) + goto out; + ret = glusterd_create_sub_tier_volinfo (volinfo, &dup_volinfo, + _gf_true, volname); + if (ret < 0) + goto out; + ret = glusterd_shd_select_brick_xlator (dict, heal_op, + dup_volinfo, + &index, &hxlator_count, + rsp_dict); + glusterd_volinfo_delete (dup_volinfo); + if (ret < 0) + goto out; + } else { + ret = glusterd_shd_select_brick_xlator (dict, heal_op, + volinfo, + &index, &hxlator_count, + rsp_dict); + if (ret < 0) + goto out; + } pending_node = GF_CALLOC (1, sizeof (*pending_node), gf_gld_mt_pending_node_t); @@ -6433,6 +6471,21 @@ glusterd_bricks_select_heal_volume (dict_t *dict, char **op_errstr, pending_node = NULL; } + if (!hxlator_count) + goto out; + if (hxlator_count == -1) { + gf_msg (this->name, GF_LOG_ERROR, 0, + GD_MSG_XLATOR_COUNT_GET_FAIL, "Could not determine the" + "translator count"); + ret = -1; + goto out; + } + + ret = dict_set_int32 (dict, "count", hxlator_count); + if (ret) + goto out; + + out: gf_msg_debug (THIS->name, 0, "Returning ret %d", ret); return ret; diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.c b/xlators/mgmt/glusterd/src/glusterd-utils.c index 39518d1b534..e368147584f 100644 --- a/xlators/mgmt/glusterd/src/glusterd-utils.c +++ b/xlators/mgmt/glusterd/src/glusterd-utils.c @@ -6368,14 +6368,24 @@ out: return ret; } +static inline int +is_replica_volume (int type) +{ + if (type == GF_CLUSTER_TYPE_REPLICATE || + type == GF_CLUSTER_TYPE_STRIPE_REPLICATE) + return 1; + return 0; +} gf_boolean_t glusterd_is_volume_replicate (glusterd_volinfo_t *volinfo) { gf_boolean_t replicates = _gf_false; - if (volinfo && ((volinfo->type == GF_CLUSTER_TYPE_REPLICATE) || - (volinfo->type == GF_CLUSTER_TYPE_STRIPE_REPLICATE))) - replicates = _gf_true; - return replicates; + if (volinfo->type == GF_CLUSTER_TYPE_TIER) { + replicates = is_replica_volume (volinfo->tier_info.cold_type) | + is_replica_volume (volinfo->tier_info.hot_type); + return replicates; + } + return is_replica_volume ((volinfo->type)); } gf_boolean_t diff --git a/xlators/mgmt/glusterd/src/glusterd-volgen.c b/xlators/mgmt/glusterd/src/glusterd-volgen.c index 09bc94621f4..a13e70eea35 100644 --- a/xlators/mgmt/glusterd/src/glusterd-volgen.c +++ b/xlators/mgmt/glusterd/src/glusterd-volgen.c @@ -19,6 +19,7 @@ #include "logging.h" #include "dict.h" #include "graph-utils.h" +#include "common-utils.h" #include "glusterd-store.h" #include "glusterd-hooks.h" #include "trie.h" @@ -3290,6 +3291,7 @@ volgen_graph_build_afr_clusters (volgen_graph_t *graph, if (volinfo->tier_info.cold_type == GF_CLUSTER_TYPE_REPLICATE) start_count = volinfo->tier_info.cold_brick_count / volinfo->tier_info.cold_replica_count; + if (volinfo->tier_info.cur_tier_hot) clusters = volgen_link_bricks_from_list_head_start (graph, volinfo, @@ -3567,6 +3569,7 @@ volume_volgen_graph_build_clusters_tier (volgen_graph_t *graph, start_count = volinfo->tier_info.cold_brick_count / volinfo->tier_info.cold_replica_count; } + if (volinfo->dist_leaf_count != 1) { ret = volgen_link_bricks_from_list_head_start (graph, volinfo, @@ -4222,11 +4225,11 @@ nfs_option_handler (volgen_graph_t *graph, } char* -volgen_get_shd_key (glusterd_volinfo_t *volinfo) +volgen_get_shd_key (int type) { char *key = NULL; - switch (volinfo->type) { + switch (type) { case GF_CLUSTER_TYPE_REPLICATE: case GF_CLUSTER_TYPE_STRIPE_REPLICATE: key = "cluster.self-heal-daemon"; @@ -4234,9 +4237,6 @@ volgen_get_shd_key (glusterd_volinfo_t *volinfo) case GF_CLUSTER_TYPE_DISPERSE: key = "cluster.disperse-self-heal-daemon"; break; - case GF_CLUSTER_TYPE_TIER: - key = "cluster.tier-self-heal-daemon"; - break; default: key = NULL; break; @@ -4273,6 +4273,30 @@ volgen_graph_set_iam_shd (volgen_graph_t *graph) return ret; } +static int +prepare_shd_volume_options_for_tier (glusterd_volinfo_t *volinfo, + dict_t *set_dict) +{ + int ret = -1; + char *key = NULL; + + key = volgen_get_shd_key (volinfo->tier_info.cold_type); + if (key) { + ret = dict_set_str (set_dict, key, "enable"); + if (ret) + goto out; + } + + key = volgen_get_shd_key (volinfo->tier_info.hot_type); + if (key) { + ret = dict_set_str (set_dict, key, "enable"); + if (ret) + goto out; + } +out: + return ret; +} + static int prepare_shd_volume_options (glusterd_volinfo_t *volinfo, dict_t *mod_dict, dict_t *set_dict) @@ -4280,16 +4304,21 @@ prepare_shd_volume_options (glusterd_volinfo_t *volinfo, char *key = NULL; int ret = 0; - key = volgen_get_shd_key (volinfo); - if (!key) { - ret = -1; - goto out; + if (volinfo->type == GF_CLUSTER_TYPE_TIER) { + ret = prepare_shd_volume_options_for_tier (volinfo, set_dict); + if (ret) + goto out; + } else { + key = volgen_get_shd_key (volinfo->type); + if (!key) { + ret = -1; + goto out; + } + ret = dict_set_str (set_dict, key, "enable"); + if (ret) + goto out; } - ret = dict_set_str (set_dict, key, "enable"); - if (ret) - goto out; - ret = dict_set_uint32 (set_dict, "trusted-client", GF_CLIENT_TRUSTED); if (ret) goto out; @@ -4400,6 +4429,42 @@ out: return clusters; } +gf_boolean_t +is_self_heal_enabled (glusterd_volinfo_t *volinfo, dict_t *dict) +{ + + char *shd_key = NULL; + gf_boolean_t shd_enabled = _gf_false; + + GF_VALIDATE_OR_GOTO ("glusterd", volinfo, out); + + switch (volinfo->type) { + case GF_CLUSTER_TYPE_REPLICATE: + case GF_CLUSTER_TYPE_STRIPE_REPLICATE: + case GF_CLUSTER_TYPE_DISPERSE: + shd_key = volgen_get_shd_key (volinfo->type); + shd_enabled = dict_get_str_boolean (dict, shd_key, + _gf_true); + break; + case GF_CLUSTER_TYPE_TIER: + shd_key = volgen_get_shd_key (volinfo->tier_info.cold_type); + if (shd_key) + shd_enabled = dict_get_str_boolean (dict, shd_key, + _gf_true); + + shd_key = volgen_get_shd_key (volinfo->tier_info.hot_type); + if (shd_key) + shd_enabled |= dict_get_str_boolean (dict, shd_key, + _gf_true); + + break; + default: + break; + } +out: + return shd_enabled; +} + static int build_rebalance_volfile (glusterd_volinfo_t *volinfo, char *filepath, dict_t *mod_dict) diff --git a/xlators/mgmt/glusterd/src/glusterd-volgen.h b/xlators/mgmt/glusterd/src/glusterd-volgen.h index 2dccfca8407..f5f922475f0 100644 --- a/xlators/mgmt/glusterd/src/glusterd-volgen.h +++ b/xlators/mgmt/glusterd/src/glusterd-volgen.h @@ -280,11 +280,12 @@ gd_is_boolean_option (char *key); char* -volgen_get_shd_key (glusterd_volinfo_t *volinfo); +volgen_get_shd_key (int type); int glusterd_volopt_validate (glusterd_volinfo_t *volinfo, dict_t *dict, char *key, char *value, char **op_errstr); - +gf_boolean_t +is_self_heal_enabled (glusterd_volinfo_t *volinfo, dict_t *dict); #endif diff --git a/xlators/mgmt/glusterd/src/glusterd-volume-ops.c b/xlators/mgmt/glusterd/src/glusterd-volume-ops.c index a07d7612576..b00539d4efa 100644 --- a/xlators/mgmt/glusterd/src/glusterd-volume-ops.c +++ b/xlators/mgmt/glusterd/src/glusterd-volume-ops.c @@ -669,14 +669,73 @@ out: return ret; } - int glusterd_handle_cli_delete_volume (rpcsvc_request_t *req) { return glusterd_big_locked_handler (req, __glusterd_handle_cli_delete_volume); } +static char* +_get_shd_key (int type) +{ + char *key = NULL; + + switch (type) { + case GF_CLUSTER_TYPE_REPLICATE: + case GF_CLUSTER_TYPE_STRIPE_REPLICATE: + key = "cluster.self-heal-daemon"; + break; + case GF_CLUSTER_TYPE_DISPERSE: + key = "cluster.disperse-self-heal-daemon"; + break; + default: + key = NULL; + break; + } + return key; +} +static int +glusterd_handle_shd_option_for_tier (glusterd_volinfo_t *volinfo, + char *value, dict_t *dict) +{ + int count = 0; + char dict_key[1024] = {0, }; + char *key = NULL; + int ret = 0; + + key = _get_shd_key (volinfo->tier_info.cold_type); + if (key) { + count++; + snprintf (dict_key, sizeof (dict_key), "key%d", count); + ret = dict_set_str (dict, dict_key, key); + if (ret) + goto out; + snprintf (dict_key, sizeof (dict_key), "value%d", count); + ret = dict_set_str (dict, dict_key, value); + if (ret) + goto out; + } + + key = _get_shd_key (volinfo->tier_info.hot_type); + if (key) { + count++; + snprintf (dict_key, sizeof (dict_key), "key%d", count); + ret = dict_set_str (dict, dict_key, key); + if (ret) + goto out; + snprintf (dict_key, sizeof (dict_key), "value%d", count); + ret = dict_set_str (dict, dict_key, value); + if (ret) + goto out; + } + + ret = dict_set_int32 (dict, "count", count); + if (ret) + goto out; +out: + return ret; +} static int glusterd_handle_heal_enable_disable (rpcsvc_request_t *req, dict_t *dict, glusterd_volinfo_t *volinfo) @@ -699,23 +758,31 @@ glusterd_handle_heal_enable_disable (rpcsvc_request_t *req, dict_t *dict, goto out; } - key = volgen_get_shd_key (volinfo); + if (heal_op == GF_SHD_OP_HEAL_ENABLE) { + value = "enable"; + } else if (heal_op == GF_SHD_OP_HEAL_DISABLE) { + value = "disable"; + } + + /* Convert this command to volume-set command based on volume type */ + if (volinfo->type == GF_CLUSTER_TYPE_TIER) { + ret = glusterd_handle_shd_option_for_tier (volinfo, value, + dict); + if (!ret) + goto set_volume; + goto out; + } + + key = volgen_get_shd_key (volinfo->type); if (!key) { ret = -1; goto out; } - /* Convert this command to volume-set command based on volume type */ ret = dict_set_str (dict, "key1", key); if (ret) goto out; - if (heal_op == GF_SHD_OP_HEAL_ENABLE) { - value = "enable"; - } else if (heal_op == GF_SHD_OP_HEAL_DISABLE) { - value = "disable"; - } - ret = dict_set_str (dict, "value1", value); if (ret) goto out; @@ -724,6 +791,7 @@ glusterd_handle_heal_enable_disable (rpcsvc_request_t *req, dict_t *dict, if (ret) goto out; +set_volume: ret = glusterd_op_begin_synctask (req, GD_OP_SET_VOLUME, dict); out: @@ -1822,9 +1890,7 @@ glusterd_op_stage_heal_volume (dict_t *dict, char **op_errstr) ret = 0; goto out; } - - enabled = dict_get_str_boolean (opt_dict, volgen_get_shd_key (volinfo), - 1); + enabled = is_self_heal_enabled (volinfo, opt_dict); if (!enabled) { ret = -1; snprintf (msg, sizeof (msg), "Self-heal-daemon is " diff --git a/xlators/mgmt/glusterd/src/glusterd-volume-set.c b/xlators/mgmt/glusterd/src/glusterd-volume-set.c index 8fdee165c68..58405b67363 100644 --- a/xlators/mgmt/glusterd/src/glusterd-volume-set.c +++ b/xlators/mgmt/glusterd/src/glusterd-volume-set.c @@ -412,6 +412,16 @@ validate_disperse_heal_enable_disable (glusterd_volinfo_t *volinfo, char **op_errstr) { int ret = 0; + if (volinfo->type == GF_CLUSTER_TYPE_TIER) { + if (volinfo->tier_info.cold_type != GF_CLUSTER_TYPE_DISPERSE && + volinfo->tier_info.hot_type != GF_CLUSTER_TYPE_DISPERSE) { + gf_asprintf (op_errstr, "Volume %s is not containing " + "disperse type", volinfo->volname); + + return -1; + } else + return 0; + } if (volinfo->type != GF_CLUSTER_TYPE_DISPERSE) { gf_asprintf (op_errstr, "Volume %s is not of disperse type", -- cgit