xlators - glusterfs.git -

Mode	Name	Size
-rw-r--r--	Makefile.am	94	log stats plain
d---------	bindings	72	log stats plain
d---------	cluster	223	log stats plain
d---------	debug	142	log stats plain
d---------	encryption	72	log stats plain
d---------	features	209	log stats plain
d---------	meta	69	log stats plain
d---------	mount	70	log stats plain
d---------	performance	304	log stats plain
d---------	protocol	105	log stats plain
d---------	storage	101	log stats plain

"to continue?";

if ((wordcount < 3) || (wordcount > 4)) {

cli_usage_out (word->pattern);

@@ -120,14 +124,40 @@ cli_cmd_sync_volume_cbk (struct cli_state *state, struct cli_cmd_word *word,

goto out;

}

+ dict = dict_new ();

+ if (!dict)

+ goto out;

if ((wordcount == 3) || !strcmp(words[3], "all")) {

- req.flags = GF_CLI_SYNC_ALL;

- req.volname = "";

+ ret = dict_set_int32 (dict, "flags", (int32_t)

+ GF_CLI_SYNC_ALL);

+ if (ret) {

+ gf_log (THIS->name, GF_LOG_ERROR, "failed to set"

+ "flag");

+ goto out;

+ }

} else {

- req.volname = (char *)words[3];

+ ret = dict_set_str (dict, "volname", (char *) words[3]);

+ if (ret) {

+ gf_log (THIS->name, GF_LOG_ERROR, "failed to set "

+ "volume");

+ goto out;

+ }

+ ret = dict_set_str (dict, "hostname", (char *) words[2]);

+ if (ret) {

+ gf_log (THIS->name, GF_LOG_ERROR, "failed to set hostname");

+ goto out;

}

- req.hostname = (char *)words[2];

+ if (!(state->mode & GLUSTER_MODE_SCRIPT)) {

+ answer = cli_cmd_get_confirmation (state, question);

+ if (GF_ANSWER_NO == answer) {

+ ret = 0;

+ goto out;

+ }

proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SYNC_VOLUME];

@@ -135,8 +165,10 @@ cli_cmd_sync_volume_cbk (struct cli_state *state, struct cli_cmd_word *word,

if (!frame)

goto out;

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

if (proc->fn) {

- ret = proc->fn (frame, THIS, &req);

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

}

out:

@@ -146,6 +178,156 @@ out:

cli_out ("Volume sync failed");

}

+ CLI_STACK_DESTROY (frame);

+ return ret;

+gf_ai_compare_t

+cli_cmd_compare_addrinfo (struct addrinfo *first, struct addrinfo *next)

+ int ret = -1;

+ struct addrinfo *tmp1 = NULL;

+ struct addrinfo *tmp2 = NULL;

+ char firstip[NI_MAXHOST] = {0.};

+ char nextip[NI_MAXHOST] = {0,};

+ for (tmp1 = first; tmp1 != NULL; tmp1 = tmp1->ai_next) {

+ ret = getnameinfo (tmp1->ai_addr, tmp1->ai_addrlen, firstip,

+ NI_MAXHOST, NULL, 0, NI_NUMERICHOST);

+ if (ret)

+ return GF_AI_COMPARE_ERROR;

+ for (tmp2 = next; tmp2 != NULL; tmp2 = tmp2->ai_next) {

+ ret = getnameinfo (tmp2->ai_addr, tmp2->ai_addrlen, nextip,

+ NI_MAXHOST, NULL, 0, NI_NUMERICHOST);

+ if (ret)

+ return GF_AI_COMPARE_ERROR;

+ if (!strcmp (firstip, nextip)) {

+ return GF_AI_COMPARE_MATCH;

+ }

+ return GF_AI_COMPARE_NO_MATCH;

+/* Check for non optimal brick order for replicate :

+ * Checks if bricks belonging to a replicate volume

+ * are present on the same server

+ */

+int32_t

+cli_cmd_check_brick_order (struct cli_state *state, const char *bricks,

+ int brick_count, int sub_count)

+ int ret = -1;

+ int i = 0;

+ int j = 0;

+ int k = 0;

+ addrinfo_list_t *ai_list = NULL;

+ addrinfo_list_t *ai_list_tmp1 = NULL;

+ addrinfo_list_t *ai_list_tmp2 = NULL;

+ char *brick = NULL;

+ char *brick_list = NULL;

+ char *brick_list_dup = NULL;

+ char *tmpptr = NULL;

+ struct addrinfo *ai_info = NULL;

+ gf_answer_t answer = GF_ANSWER_NO;

+ const char *failed_question = NULL;

+ const char *found_question = NULL;

+ failed_question = "Failed to perform brick order check. "

+ "Do you want to continue creating the volume? ";

+ found_question = "Multiple bricks of a replicate volume are present"

+ " on the same server. This setup is not optimal.\n"

+ "Do you still want to continue creating the volume? ";

+ GF_ASSERT (bricks);

+ GF_ASSERT (brick_count > 0);

+ GF_ASSERT (sub_count > 0);

+ ai_list = malloc (sizeof (addrinfo_list_t));

+ ai_list->info = NULL;

+ INIT_LIST_HEAD (&ai_list->list);

+ brick_list = gf_strdup (bricks);

+ if (brick_list == NULL) {

+ gf_log ("cli", GF_LOG_DEBUG, "failed to allocate memory");

+ goto check_failed;

+ }

+ brick_list_dup = brick_list;

+ /* Resolve hostnames and get addrinfo */

+ while (i < brick_count) {

+ ++i;

+ brick = strtok_r (brick_list, " \n", &tmpptr);

+ brick_list = tmpptr;

+ if (brick == NULL)

+ goto check_failed;

+ brick = strtok_r (brick, ":", &tmpptr);

+ if (brick == NULL)

+ goto check_failed;

+ ret = getaddrinfo (brick, NULL, NULL, &ai_info);

+ if (ret)

+ goto check_failed;

+ ai_list_tmp1 = malloc (sizeof (addrinfo_list_t));

+ if (ai_list_tmp1 == NULL)

+ goto check_failed;

+ ai_list_tmp1->info = ai_info;

+ list_add_tail (&ai_list_tmp1->list, &ai_list->list);

+ ai_list_tmp1 = NULL;

+ }

+ i = 0;

+ ai_list_tmp1 = list_entry (ai_list->list.next, addrinfo_list_t, list);

+ /* Check for bad brick order */

+ while (i < brick_count) {

+ ++i;

+ ai_info = ai_list_tmp1->info;

+ ai_list_tmp1 = list_entry (ai_list_tmp1->list.next,

+ addrinfo_list_t, list);

+ if ( 0 == i % sub_count) {

+ j = 0;

+ continue;

+ }

+ ai_list_tmp2 = ai_list_tmp1;

+ k = j;

+ while (k < sub_count - 1) {

+ ++k;

+ ret = cli_cmd_compare_addrinfo (ai_info,

+ ai_list_tmp2->info);

+ if (GF_AI_COMPARE_ERROR == ret)

+ goto check_failed;

+ if (GF_AI_COMPARE_MATCH == ret)

+ goto found_bad_brick_order;

+ ai_list_tmp2 = list_entry (ai_list_tmp2->list.next,

+ addrinfo_list_t, list);

+ }

+ ++j;

+ }

+ gf_log ("cli", GF_LOG_INFO, "Brick order okay");

+ ret = 0;

+ goto out;

+check_failed:

+ gf_log ("cli", GF_LOG_INFO, "Failed bad brick order check");

+ answer = cli_cmd_get_confirmation(state, failed_question);

+ if (GF_ANSWER_YES == answer)

+ ret = 0;

+ goto out;

+found_bad_brick_order:

+ gf_log ("cli", GF_LOG_INFO, "Bad brick order found");

+ answer = cli_cmd_get_confirmation (state, found_question);

+ if (GF_ANSWER_YES == answer)

+ ret = 0;

+out:

+ ai_list_tmp2 = NULL;

+ i = 0;

+ GF_FREE (brick_list_dup);

+ list_for_each_entry (ai_list_tmp1, &ai_list->list, list) {

+ if (ai_list_tmp1->info)

+ freeaddrinfo (ai_list_tmp1->info);

+ free (ai_list_tmp2);

+ ai_list_tmp2 = ai_list_tmp1;

+ }

+ free (ai_list_tmp2);

return ret;

}

@@ -159,6 +341,11 @@ cli_cmd_volume_create_cbk (struct cli_state *state, struct cli_cmd_word *word,

dict_t *options = NULL;

int sent = 0;

int parse_error = 0;

+ char *brick_list = NULL;

+ int32_t brick_count = 0;

+ int32_t sub_count = 0;

+ int32_t type = GF_CLUSTER_TYPE_NONE;

+ cli_local_t *local = NULL;

proc = &cli_rpc_prog->proctable[GLUSTER_CLI_CREATE_VOLUME];

@@ -173,20 +360,62 @@ cli_cmd_volume_create_cbk (struct cli_state *state, struct cli_cmd_word *word,

parse_error = 1;

goto out;

}

+ /*Check brick order if type is replicate*/

+ ret = dict_get_int32 (options, "type", &type);

+ if (ret) {

+ gf_log ("cli", GF_LOG_ERROR, "Could not get brick type");

+ goto out;

+ }

+ if ((type == GF_CLUSTER_TYPE_REPLICATE) ||

+ (type == GF_CLUSTER_TYPE_STRIPE_REPLICATE)) {

+ if ((ret = dict_get_str (options, "bricks", &brick_list)) != 0) {

+ gf_log ("cli", GF_LOG_ERROR, "Replica bricks check : "

+ "Could not retrieve bricks list");

+ goto out;

+ }

+ if ((ret = dict_get_int32 (options, "count", &brick_count)) != 0) {

+ gf_log ("cli", GF_LOG_ERROR, "Replica bricks check : "

+ "Could not retrieve brick count");

+ goto out;

+ }

+ if ((ret = dict_get_int32 (options, "replica-count", &sub_count)) != 0) {

+ gf_log ("cli", GF_LOG_ERROR, "Replica bricks check : "

+ "Could not retrieve replica count");

+ goto out;

+ }

+ gf_log ("cli", GF_LOG_INFO, "Replicate cluster type found."

+ " Checking brick order.");

+ ret = cli_cmd_check_brick_order (state, brick_list, brick_count, sub_count);

+ if (ret) {

+ gf_log("cli", GF_LOG_INFO, "Not creating volume because of bad brick order");

+ goto out;

+ }

+ if (state->mode & GLUSTER_MODE_SCRIPT) {

+ 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) {

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

}

out:

- if (options)

- dict_unref (options);

if (ret) {

cli_cmd_sent_status_get (&sent);

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

cli_out ("Volume create failed");

}

+ CLI_STACK_DESTROY (frame);

return ret;

}

@@ -203,6 +432,8 @@ cli_cmd_volume_delete_cbk (struct cli_state *state, struct cli_cmd_word *word,

const char *question = NULL;

int sent = 0;

int parse_error = 0;

+ cli_local_t *local = NULL;

+ dict_t *dict = NULL;

question = "Deleting volume will erase all information about the volume. "

"Do you want to continue?";

@@ -212,6 +443,10 @@ cli_cmd_volume_delete_cbk (struct cli_state *state, struct cli_cmd_word *word,

if (!frame)

goto out;

+ dict = dict_new ();

+ if (!dict)

+ goto out;

if (wordcount != 3) {

cli_usage_out (word->pattern);

parse_error = 1;

@@ -227,8 +462,17 @@ cli_cmd_volume_delete_cbk (struct cli_state *state, struct cli_cmd_word *word,

volname = (char *)words[2];

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

+ if (ret) {

+ gf_log (THIS->name, GF_LOG_WARNING, "dict set failed");

+ goto out;

+ }

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

if (proc->fn) {

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

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

}

out:

@@ -238,6 +482,8 @@ out:

cli_out ("Volume delete failed");

}

+ CLI_STACK_DESTROY (frame);

return ret;

}

@@ -248,9 +494,11 @@ cli_cmd_volume_start_cbk (struct cli_state *state, struct cli_cmd_word *word,

int ret = -1;

rpc_clnt_procedure_t *proc = NULL;

call_frame_t *frame = NULL;

- gf1_cli_start_vol_req req = {0,};

int sent = 0;

int parse_error = 0;

+ dict_t *dict = NULL;

+ int flags = 0;

+ cli_local_t *local = NULL;

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

if (!frame)

@@ -262,13 +510,23 @@ cli_cmd_volume_start_cbk (struct cli_state *state, struct cli_cmd_word *word,

goto out;

}

- req.volname = (char *)words[2];

- if (!req.volname)

+ dict = dict_new ();

+ if (!dict) {

+ goto out;

+ }

+ if (!words[2])

+ goto out;

+ ret = dict_set_str (dict, "volname", (char *)words[2]);

+ if (ret) {

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

goto out;

+ }

if (wordcount == 4) {

if (!strcmp("force", words[3])) {

- req.flags |= GF_CLI_FLAG_OP_FORCE;

+ flags |= GF_CLI_FLAG_OP_FORCE;

} else {

ret = -1;

cli_usage_out (word->pattern);

@@ -276,11 +534,25 @@ cli_cmd_volume_start_cbk (struct cli_state *state, struct cli_cmd_word *word,

goto out;

}

+ ret = dict_set_int32 (dict, "flags", flags);

+ if (ret) {

+ gf_log (THIS->name, GF_LOG_ERROR,

+ "dict set failed");

+ goto out;

+ }

+ if (ret < 0) {

+ gf_log (THIS->name, GF_LOG_ERROR,

+ "failed to serialize dict");

+ goto out;

+ }

proc = &cli_rpc_prog->proctable[GLUSTER_CLI_START_VOLUME];

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

if (proc->fn) {

- ret = proc->fn (frame, THIS, &req);

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

}

out:

@@ -290,6 +562,8 @@ out:

cli_out ("Volume start failed");

}

+ CLI_STACK_DESTROY (frame);

return ret;

}

@@ -298,18 +572,21 @@ cli_cmd_get_confirmation (struct cli_state *state, const char *question)

{

char answer[5] = {'\0', };

char flush = '\0';

- int len = 0;

+ size_t len;

if (state->mode & GLUSTER_MODE_SCRIPT)

return GF_ANSWER_YES;

printf ("%s (y/n) ", question);

- fgets (answer, 4, stdin);

+ if (fgets (answer, 4, stdin) == NULL) {

+ cli_out("gluster cli read error");

+ goto out;

+ }

len = strlen (answer);

- if (answer [len - 1] == '\n'){

+ if (len && answer [len - 1] == '\n'){