diff options
Diffstat (limited to 'cli/src/cli.c')
| -rw-r--r-- | cli/src/cli.c | 1086 |
1 files changed, 741 insertions, 345 deletions
diff --git a/cli/src/cli.c b/cli/src/cli.c index 58cb61bb417..a52b39c5fb8 100644 --- a/cli/src/cli.c +++ b/cli/src/cli.c @@ -1,22 +1,12 @@ /* - Copyright (c) 2010 Gluster, Inc. <http://www.gluster.com> - This file is part of GlusterFS. - - GlusterFS is free software; you can redistribute it and/or modify - it under the terms of the GNU Affero General Public License as published - by the Free Software Foundation; either version 3 of the License, - or (at your option) any later version. - - GlusterFS is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Affero General Public License for more details. - - You should have received a copy of the GNU Affero General Public License - along with this program. If not, see - <http://www.gnu.org/licenses/>. -*/ + Copyright (c) 2010-2016 Red Hat, Inc. <http://www.redhat.com> + This file is part of GlusterFS. + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. +*/ #include <stdio.h> #include <string.h> #include <stdlib.h> @@ -39,478 +29,884 @@ #include <semaphore.h> #include <errno.h> -#ifndef _CONFIG_H -#define _CONFIG_H -#include "config.h" -#endif - #ifdef HAVE_MALLOC_H #include <malloc.h> #endif -#ifdef HAVE_MALLOC_STATS -#ifdef DEBUG -#include <mcheck.h> -#endif -#endif - #include "cli.h" +#include "cli-quotad-client.h" #include "cli-cmd.h" #include "cli-mem-types.h" -#include "xlator.h" -#include "glusterfs.h" -#include "compat.h" -#include "logging.h" -#include "dict.h" -#include "list.h" -#include "timer.h" -#include "stack.h" -#include "revision.h" -#include "common-utils.h" -#include "event.h" -#include "globals.h" -#include "syscall.h" -#include "call-stub.h" +#include <glusterfs/xlator.h> +#include <glusterfs/glusterfs.h> +#include <glusterfs/compat.h> +#include <glusterfs/logging.h> +#include <glusterfs/dict.h> +#include <glusterfs/list.h> +#include <glusterfs/timer.h> +#include <glusterfs/stack.h> +#include <glusterfs/revision.h> +#include <glusterfs/common-utils.h> +#include <glusterfs/gf-event.h> +#include <glusterfs/syscall.h> +#include <glusterfs/call-stub.h> #include <fnmatch.h> -extern int connected; -/* using argp for command line parsing */ +#include "xdr-generic.h" -const char *argp_program_version = "" \ - PACKAGE_NAME" "PACKAGE_VERSION" built on "__DATE__" "__TIME__ \ - "\nRepository revision: " GLUSTERFS_REPOSITORY_REVISION "\n" \ - "Copyright (c) 2006-2010 Gluster Inc. " \ - "<http://www.gluster.com>\n" \ - "GlusterFS comes with ABSOLUTELY NO WARRANTY.\n" \ - "You may redistribute copies of GlusterFS under the terms of "\ - "the GNU Affero General Public License."; +/* using argp for command line parsing */ +const char *argp_program_version = + "" PACKAGE_NAME " " PACKAGE_VERSION + "\nRepository revision: " GLUSTERFS_REPOSITORY_REVISION + "\n" + "Copyright (c) 2006-2016 Red Hat, Inc. " + "<https://www.gluster.org/>\n" + "GlusterFS comes with ABSOLUTELY NO WARRANTY.\n" + "It is licensed to you under your choice of the GNU Lesser\n" + "General Public License, version 3 or any later version (LGPLv3\n" + "or later), or the GNU General Public License, version 2 (GPLv2),\n" + "in all cases as published by the Free Software Foundation."; const char *argp_program_bug_address = "<" PACKAGE_BUGREPORT ">"; - +struct rpc_clnt *global_quotad_rpc; struct rpc_clnt *global_rpc; rpc_clnt_prog_t *cli_rpc_prog; +extern struct rpc_clnt_program cli_prog; -extern struct rpc_clnt_program cli3_1_prog; +int cli_default_conn_timeout = 120; +int cli_ten_minutes_timeout = 600; - - - -static char * -generate_uuid () +static int +glusterfs_ctx_defaults_init(glusterfs_ctx_t *ctx) { - char tmp_str[1024] = {0,}; - char hostname[256] = {0,}; - struct timeval tv = {0,}; - struct tm now = {0, }; - char now_str[32]; - - if (gettimeofday (&tv, NULL) == -1) { - gf_log ("glusterfsd", GF_LOG_ERROR, - "gettimeofday: failed %s", - strerror (errno)); - } - - if (gethostname (hostname, 256) == -1) { - gf_log ("glusterfsd", GF_LOG_ERROR, - "gethostname: failed %s", - strerror (errno)); - } + cmd_args_t *cmd_args = NULL; + struct rlimit lim = { + 0, + }; + call_pool_t *pool = NULL; + int ret = -1; + + if (!ctx) + return ret; - localtime_r (&tv.tv_sec, &now); - strftime (now_str, 32, "%Y/%m/%d-%H:%M:%S", &now); - snprintf (tmp_str, 1024, "%s-%d-%s:%" -#ifdef GF_DARWIN_HOST_OS - PRId32, -#else - "ld", -#endif - hostname, getpid(), now_str, tv.tv_usec); + ret = xlator_mem_acct_init(THIS, cli_mt_end); + if (ret != 0) { + gf_log("cli", GF_LOG_ERROR, "Memory accounting init failed."); + return ret; + } + + /* Resetting ret to -1 to so in case of failure + * we can relese allocated resource. + */ + ret = -1; + + ctx->process_uuid = generate_glusterfs_ctx_id(); + if (!ctx->process_uuid) { + gf_log("cli", GF_LOG_ERROR, "Failed to generate uuid."); + goto out; + } + + ctx->page_size = 128 * GF_UNIT_KB; + + ctx->iobuf_pool = iobuf_pool_new(); + if (!ctx->iobuf_pool) { + gf_log("cli", GF_LOG_ERROR, "Failed to create iobuf pool."); + goto out; + } + + ctx->event_pool = gf_event_pool_new(DEFAULT_EVENT_POOL_SIZE, + STARTING_EVENT_THREADS); + if (!ctx->event_pool) { + gf_log("cli", GF_LOG_ERROR, "Failed to create event pool."); + goto out; + } + + pool = GF_CALLOC(1, sizeof(call_pool_t), cli_mt_call_pool_t); + if (!pool) { + gf_log("cli", GF_LOG_ERROR, "Failed to create call pool."); + goto out; + } + + /* frame_mem_pool size 112 * 64 */ + pool->frame_mem_pool = mem_pool_new(call_frame_t, 32); + if (!pool->frame_mem_pool) { + gf_log("cli", GF_LOG_ERROR, "Failed to create frame mem pool."); + goto out; + } + + /* stack_mem_pool size 256 * 128 */ + pool->stack_mem_pool = mem_pool_new(call_stack_t, 16); + + if (!pool->stack_mem_pool) { + gf_log("cli", GF_LOG_ERROR, "Failed to create stack mem pool."); + goto out; + } + + ctx->stub_mem_pool = mem_pool_new(call_stub_t, 16); + if (!ctx->stub_mem_pool) { + gf_log("cli", GF_LOG_ERROR, "Failed to stub mem pool."); + goto out; + } + + ctx->dict_pool = mem_pool_new(dict_t, 32); + if (!ctx->dict_pool) { + gf_log("cli", GF_LOG_ERROR, "Failed to create dict pool."); + goto out; + } + + ctx->dict_pair_pool = mem_pool_new(data_pair_t, 512); + if (!ctx->dict_pair_pool) { + gf_log("cli", GF_LOG_ERROR, "Failed to create dict pair pool."); + goto out; + } + + ctx->dict_data_pool = mem_pool_new(data_t, 512); + if (!ctx->dict_data_pool) { + gf_log("cli", GF_LOG_ERROR, "Failed to create dict data pool."); + goto out; + } + + ctx->logbuf_pool = mem_pool_new(log_buf_t, 256); + if (!ctx->logbuf_pool) { + gf_log("cli", GF_LOG_ERROR, "Failed to create logbuf pool."); + goto out; + } + + INIT_LIST_HEAD(&pool->all_frames); + LOCK_INIT(&pool->lock); + ctx->pool = pool; + + cmd_args = &ctx->cmd_args; + + INIT_LIST_HEAD(&cmd_args->xlator_options); + + lim.rlim_cur = RLIM_INFINITY; + lim.rlim_max = RLIM_INFINITY; + setrlimit(RLIMIT_CORE, &lim); + + ret = 0; - return gf_strdup (tmp_str); +out: + if (ret != 0) { + if (pool) { + mem_pool_destroy(pool->frame_mem_pool); + mem_pool_destroy(pool->stack_mem_pool); + } + GF_FREE(pool); + pool = NULL; + GF_FREE(ctx->process_uuid); + mem_pool_destroy(ctx->stub_mem_pool); + mem_pool_destroy(ctx->dict_pool); + mem_pool_destroy(ctx->dict_pair_pool); + mem_pool_destroy(ctx->dict_data_pool); + mem_pool_destroy(ctx->logbuf_pool); + } + + return ret; } static int -glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx) +logging_init(glusterfs_ctx_t *ctx, struct cli_state *state) { - cmd_args_t *cmd_args = NULL; - struct rlimit lim = {0, }; - call_pool_t *pool = NULL; - - xlator_mem_acct_init (THIS, cli_mt_end); - - ctx->process_uuid = generate_uuid (); - if (!ctx->process_uuid) - return -1; - - ctx->page_size = 128 * GF_UNIT_KB; - - ctx->iobuf_pool = iobuf_pool_new (8 * GF_UNIT_MB, ctx->page_size); - if (!ctx->iobuf_pool) - return -1; + char *log_file = state->log_file ? state->log_file + : DEFAULT_CLI_LOG_FILE_DIRECTORY + "/cli.log"; + + /* passing ident as NULL means to use default ident for syslog */ + if (gf_log_init(ctx, log_file, NULL) == -1) { + fprintf(stderr, "ERROR: failed to open logfile %s\n", log_file); + } + + /* CLI should not have something to DEBUG after the release, + hence defaulting to INFO loglevel */ + gf_log_set_loglevel(ctx, (state->log_level == GF_LOG_NONE) + ? GF_LOG_INFO + : state->log_level); + + return 0; +} - ctx->event_pool = event_pool_new (DEFAULT_EVENT_POOL_SIZE); - if (!ctx->event_pool) - return -1; +int +cli_submit_request(struct rpc_clnt *rpc, void *req, call_frame_t *frame, + rpc_clnt_prog_t *prog, int procnum, struct iobref *iobref, + xlator_t *this, fop_cbk_fn_t cbkfn, xdrproc_t xdrproc) +{ + int ret = -1; + int count = 0; + struct iovec iov = { + 0, + }; + struct iobuf *iobuf = NULL; + char new_iobref = 0; + ssize_t xdr_size = 0; + + GF_ASSERT(this); + + if (req) { + xdr_size = xdr_sizeof(xdrproc, req); + iobuf = iobuf_get2(this->ctx->iobuf_pool, xdr_size); + if (!iobuf) { + goto out; + }; - pool = GF_CALLOC (1, sizeof (call_pool_t), - cli_mt_call_pool_t); - if (!pool) - return -1; + if (!iobref) { + iobref = iobref_new(); + if (!iobref) { + goto out; + } - /* frame_mem_pool size 112 * 16k */ - pool->frame_mem_pool = mem_pool_new (call_frame_t, 16384); + new_iobref = 1; + } - if (!pool->frame_mem_pool) - return -1; + iobref_add(iobref, iobuf); - /* stack_mem_pool size 256 * 8k */ - pool->stack_mem_pool = mem_pool_new (call_stack_t, 8192); + iov.iov_base = iobuf->ptr; + iov.iov_len = iobuf_size(iobuf); - if (!pool->stack_mem_pool) - return -1; + /* Create the xdr payload */ + ret = xdr_serialize_generic(iov, req, xdrproc); + if (ret == -1) { + goto out; + } + iov.iov_len = ret; + count = 1; + } - ctx->stub_mem_pool = mem_pool_new (call_stub_t, 1024); - if (!ctx->stub_mem_pool) - return -1; + if (!rpc) + rpc = global_rpc; + /* Send the msg */ + ret = rpc_clnt_submit(rpc, prog, procnum, cbkfn, &iov, count, NULL, 0, + iobref, frame, NULL, 0, NULL, 0, NULL); + ret = 0; - INIT_LIST_HEAD (&pool->all_frames); - LOCK_INIT (&pool->lock); - ctx->pool = pool; +out: + if (new_iobref) + iobref_unref(iobref); + if (iobuf) + iobuf_unref(iobuf); + return ret; +} - pthread_mutex_init (&(ctx->lock), NULL); +int +cli_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event, + void *data) +{ + xlator_t *this = NULL; + int ret = 0; - cmd_args = &ctx->cmd_args; + this = mydata; - /* parsing command line arguments */ - cmd_args->log_file = "/dev/stderr"; - cmd_args->log_level = GF_LOG_NONE; + switch (event) { + case RPC_CLNT_CONNECT: { + cli_cmd_broadcast_connected(_gf_true); + gf_log(this->name, GF_LOG_TRACE, "got RPC_CLNT_CONNECT"); + break; + } - INIT_LIST_HEAD (&cmd_args->xlator_options); + case RPC_CLNT_DISCONNECT: { + cli_cmd_broadcast_connected(_gf_false); + gf_log(this->name, GF_LOG_TRACE, "got RPC_CLNT_DISCONNECT"); + if (!global_state->prompt && global_state->await_connected) { + ret = 1; + cli_out( + "Connection failed. Please check if gluster " + "daemon is operational."); + exit(ret); + } + break; + } - lim.rlim_cur = RLIM_INFINITY; - lim.rlim_max = RLIM_INFINITY; - setrlimit (RLIMIT_CORE, &lim); + default: + gf_log(this->name, GF_LOG_TRACE, "got some other RPC event %d", + event); + ret = 0; + break; + } - return 0; + return ret; } - -static int -logging_init (glusterfs_ctx_t *ctx) +static gf_boolean_t +is_valid_int(char *str) { - cmd_args_t *cmd_args = NULL; - - cmd_args = &ctx->cmd_args; - - if (gf_log_init (cmd_args->log_file) == -1) { - fprintf (stderr, - "failed to open logfile %s. exiting\n", - cmd_args->log_file); - return -1; - } - - gf_log_set_loglevel (cmd_args->log_level); - - return 0; + if (*str == '-') + ++str; + + /* Handle empty string or just "-".*/ + if (!*str) + return _gf_false; + + /* Check for non-digit chars in the rest of the string */ + while (*str) { + if (!isdigit(*str)) + return _gf_false; + else + ++str; + } + return _gf_true; } +/* + * ret: 0: option successfully processed + * 1: signalling end of option list + * -1: unknown option + * -2: parsing issue (avoid unknown option error) + */ int -cli_submit_request (void *req, call_frame_t *frame, - rpc_clnt_prog_t *prog, - int procnum, struct iobref *iobref, - cli_serialize_t sfunc, xlator_t *this, - fop_cbk_fn_t cbkfn) +cli_opt_parse(char *opt, struct cli_state *state) { - int ret = -1; - int count = 0; - char start_ping = 0; - struct iovec iov = {0, }; - struct iobuf *iobuf = NULL; - char new_iobref = 0; + char *oarg = NULL; + gf_boolean_t secure_mgmt_tmp = 0; + + if (strcmp(opt, "") == 0) + return 1; + if (strcmp(opt, "help") == 0) { + cli_out( + " peer help - display help for peer commands\n" + " volume help - display help for volume commands\n" + " volume bitrot help - display help for volume" + " bitrot commands\n" + " volume quota help - display help for volume" + " quota commands\n" + " snapshot help - display help for snapshot commands\n" + " global help - list global commands\n"); + exit(0); + } + + if (strcmp(opt, "version") == 0) { + cli_out("%s", argp_program_version); + exit(0); + } + + if (strcmp(opt, "print-logdir") == 0) { + cli_out("%s", DEFAULT_LOG_FILE_DIRECTORY); + exit(0); + } + + if (strcmp(opt, "print-statedumpdir") == 0) { + cli_out("%s", DEFAULT_VAR_RUN_DIRECTORY); + exit(0); + } + + if (strcmp(opt, "xml") == 0) { +#if (HAVE_LIB_XML) + state->mode |= GLUSTER_MODE_XML; +#else + cli_err("XML output not supported. Ignoring '--xml' option"); +#endif + return 0; + } - GF_ASSERT (this); + if (strcmp(opt, "nolog") == 0) { + state->mode |= GLUSTER_MODE_GLFSHEAL_NOLOG; + return 0; + } - iobuf = iobuf_get (this->ctx->iobuf_pool); - if (!iobuf) { - goto out; - }; + if (strcmp(opt, "wignore-partition") == 0) { + state->mode |= GLUSTER_MODE_WIGNORE_PARTITION; + return 0; + } - if (!iobref) { - iobref = iobref_new (); - if (!iobref) { - goto out; - } + if (strcmp(opt, "wignore") == 0) { + state->mode |= GLUSTER_MODE_WIGNORE; + return 0; + } - new_iobref = 1; + oarg = strtail(opt, "mode="); + if (oarg) { + if (strcmp(oarg, "script") == 0) { + state->mode |= GLUSTER_MODE_SCRIPT; + return 0; } - iobref_add (iobref, iobuf); + if (strcmp(oarg, "interactive") == 0) + return 0; - iov.iov_base = iobuf->ptr; - iov.iov_len = 128 * GF_UNIT_KB; + return -1; + } + oarg = strtail(opt, "remote-host="); + if (oarg) { + state->remote_host = oarg; + return 0; + } - /* Create the xdr payload */ - if (req && sfunc) { - ret = sfunc (iov, req); - if (ret == -1) { - goto out; - } - iov.iov_len = ret; - count = 1; - } + oarg = strtail(opt, "inet6"); + if (oarg) { + state->address_family = "inet6"; + return 0; + } - /* Send the msg */ - ret = rpc_clnt_submit (global_rpc, prog, procnum, cbkfn, - &iov, count, - NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL); - - if (ret == 0) { - pthread_mutex_lock (&global_rpc->conn.lock); - { - if (!global_rpc->conn.ping_started) { - start_ping = 1; - } - } - pthread_mutex_unlock (&global_rpc->conn.lock); + oarg = strtail(opt, "log-file="); + if (oarg) { + state->log_file = oarg; + return 0; + } + oarg = strtail(opt, "timeout="); + if (oarg) { + if (!is_valid_int(oarg) || atoi(oarg) <= 0) { + cli_err("timeout value should be a positive integer"); + return -2; /* -2 instead of -1 to avoid unknown option + error */ } + cli_default_conn_timeout = atoi(oarg); + return 0; + } + + oarg = strtail(opt, "log-level="); + if (oarg) { + int log_level = glusterd_check_log_level(oarg); + if (log_level == -1) + return -1; + state->log_level = (gf_loglevel_t)log_level; + return 0; + } - if (start_ping) - //client_start_ping ((void *) this); - - ret = 0; + oarg = strtail(opt, "glusterd-sock="); + if (oarg) { + state->glusterd_sock = oarg; + return 0; + } + + oarg = strtail(opt, "secure-mgmt="); + if (oarg) { + if (gf_string2boolean(oarg, &secure_mgmt_tmp) == 0) { + if (secure_mgmt_tmp) { + /* See declaration for why this is an int. */ + state->ctx->secure_mgmt = 1; + } + } else { + cli_err("invalid secure-mgmt value (ignored)"); + } + return 0; + } -out: - return ret; + return -1; } int -cli_rpc_notify (struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event, - void *data) +parse_cmdline(int argc, char *argv[], struct cli_state *state) { - xlator_t *this = NULL; - int ret = 0; - - this = mydata; - - switch (event) { - case RPC_CLNT_CONNECT: - { - - cli_cmd_broadcast_connected (); - gf_log (this->name, GF_LOG_TRACE, "got RPC_CLNT_CONNECT"); - break; + int ret = 0; + int i = 0; + int j = 0; + char *opt = NULL; + + state->argc = argc - 1; + state->argv = &argv[1]; + + /* Do this first so that an option can override. */ + if (sys_access(SECURE_ACCESS_FILE, F_OK) == 0) { + state->ctx->secure_mgmt = 1; + state->ctx->ssl_cert_depth = glusterfs_read_secure_access_file(); + } + + if (state->argc > GEO_REP_CMD_CONFIG_INDEX && + strtail(state->argv[GEO_REP_CMD_INDEX], "geo") && + strtail(state->argv[GEO_REP_CMD_CONFIG_INDEX], "co")) + goto done; + + for (i = 0; i < state->argc; i++) { + opt = strtail(state->argv[i], "--"); + if (!opt) + continue; + ret = cli_opt_parse(opt, state); + if (ret == -1) { + cli_out("unrecognized option --%s\n", opt); + usage(); + return ret; + } else if (ret == -2) { + return ret; } - - case RPC_CLNT_DISCONNECT: - { - gf_log (this->name, GF_LOG_TRACE, "got RPC_CLNT_DISCONNECT"); - connected = 0; - break; + for (j = i; j < state->argc - 1; j++) + state->argv[j] = state->argv[j + 1]; + state->argc--; + /* argv shifted, next check should be at i again */ + i--; + if (ret == 1) { + /* end of cli options */ + ret = 0; + break; } + } - default: - gf_log (this->name, GF_LOG_TRACE, - "got some other RPC event %d", event); - ret = 0; - break; - } +done: + state->argv[state->argc] = NULL; - return ret; + return ret; } int -parse_cmdline (int argc, char *argv[], struct cli_state *state) +cli_cmd_tree_init(struct cli_cmd_tree *tree) { - int ret = 0; + struct cli_cmd_word *root = NULL; + int ret = 0; - state->argc=argc-1; - state->argv=&argv[1]; + root = &tree->root; + root->tree = tree; - return ret; + return ret; } - int -cli_cmd_tree_init (struct cli_cmd_tree *tree) +cli_state_init(struct cli_state *state) { - struct cli_cmd_word *root = NULL; - int ret = 0; + struct cli_cmd_tree *tree = NULL; + int ret = 0; - root = &tree->root; - root->tree = tree; + state->log_level = GF_LOG_NONE; - return ret; -} + tree = &state->tree; + tree->state = state; + ret = cli_cmd_tree_init(tree); + + return ret; +} int -cli_state_init (struct cli_state *state) +cli_usage_out(const char *usage) { - struct cli_cmd_tree *tree = NULL; - int ret = 0; - - tree = &state->tree; - tree->state = state; + GF_ASSERT(usage); - ret = cli_cmd_tree_init (tree); + if (!usage || usage[0] == '\0') + return -1; - return ret; + cli_err("\nUsage:\n%s\n", usage); + return 0; } - int -cli_out (const char *fmt, ...) +_cli_err(const char *fmt, ...) { - struct cli_state *state = NULL; - va_list ap; - int ret = 0; - - state = global_state; + va_list ap; + int ret = 0; +#ifdef HAVE_READLINE + struct cli_state *state = global_state; +#endif - va_start (ap, fmt); + va_start(ap, fmt); #ifdef HAVE_READLINE - if (state->rl_enabled && !state->rl_processing) - return cli_rl_out(state, fmt, ap); + if (state->rl_enabled && !state->rl_processing) { + ret = cli_rl_err(state, fmt, ap); + va_end(ap); + return ret; + } #endif - ret = vprintf (fmt, ap); - printf ("\n"); + ret = vfprintf(stderr, fmt, ap); + fprintf(stderr, "\n"); + va_end(ap); + + return ret; +} + +int +_cli_out(const char *fmt, ...) +{ + va_list ap; + int ret = 0; +#ifdef HAVE_READLINE + struct cli_state *state = global_state; +#endif + va_start(ap, fmt); +#ifdef HAVE_READLINE + if (state->rl_enabled && !state->rl_processing) { + ret = cli_rl_out(state, fmt, ap); + va_end(ap); return ret; + } +#endif + + ret = vprintf(fmt, ap); + printf("\n"); + va_end(ap); + + return ret; } struct rpc_clnt * -cli_rpc_init (struct cli_state *state) +cli_quotad_clnt_rpc_init(void) { - struct rpc_clnt *rpc = NULL; - struct rpc_clnt_config rpc_cfg = {0,}; - dict_t *options = NULL; - int ret = -1; - int port = CLI_GLUSTERD_PORT; - xlator_t *this = NULL; - - - this = THIS; - cli_rpc_prog = &cli3_1_prog; - options = dict_new (); - if (!options) - goto out; + struct rpc_clnt *rpc = NULL; + dict_t *rpc_opts = NULL; + int ret = -1; + + rpc_opts = dict_new(); + if (!rpc_opts) { + ret = -1; + goto out; + } + + ret = dict_set_str(rpc_opts, "transport.address-family", "unix"); + if (ret) + goto out; + + ret = dict_set_str(rpc_opts, "transport-type", "socket"); + if (ret) + goto out; + + ret = dict_set_str(rpc_opts, "transport.socket.connect-path", + "/var/run/gluster/quotad.socket"); + if (ret) + goto out; + + rpc = cli_quotad_clnt_init(THIS, rpc_opts); + if (!rpc) + goto out; + + global_quotad_rpc = rpc; +out: + if (rpc_opts) { + dict_unref(rpc_opts); + } + return rpc; +} - ret = dict_set_str (options, "remote-host", "localhost"); +struct rpc_clnt * +cli_rpc_init(struct cli_state *state) +{ + struct rpc_clnt *rpc = NULL; + dict_t *options = NULL; + int ret = -1; + int port = CLI_GLUSTERD_PORT; + xlator_t *this = NULL; +#ifdef IPV6_DEFAULT + char *addr_family = "inet6"; +#else + char *addr_family = "inet"; +#endif + + this = THIS; + cli_rpc_prog = &cli_prog; + + options = dict_new(); + if (!options) + goto out; + + /* If address family specified in CLI */ + if (state->address_family) { + addr_family = state->address_family; + } + + /* Connect to glusterd using the specified method, giving preference + * to a unix socket connection. If nothing is specified, connect to + * the default glusterd socket. + */ + if (state->glusterd_sock) { + gf_log("cli", GF_LOG_INFO, + "Connecting to glusterd using " + "sockfile %s", + state->glusterd_sock); + ret = rpc_transport_unix_options_build(options, state->glusterd_sock, + 0); if (ret) - goto out; + goto out; + } else if (state->remote_host) { + gf_log("cli", GF_LOG_INFO, + "Connecting to remote glusterd at " + "%s", + state->remote_host); + + ret = dict_set_str(options, "remote-host", state->remote_host); + if (ret) + goto out; if (state->remote_port) - port = state->remote_port; - - rpc_cfg.remote_host = "localhost"; - rpc_cfg.remote_port = port; + port = state->remote_port; - ret = dict_set_int32 (options, "remote-port", port); + ret = dict_set_int32(options, "remote-port", port); if (ret) - goto out; + goto out; - ret = dict_set_str (options, "transport.address-family", "inet"); + ret = dict_set_str(options, "transport.address-family", addr_family); if (ret) - goto out; + goto out; + } else { + gf_log("cli", GF_LOG_DEBUG, + "Connecting to glusterd using " + "default socket"); + ret = rpc_transport_unix_options_build(options, + DEFAULT_GLUSTERD_SOCKFILE, 0); + if (ret) + goto out; + } - rpc = rpc_clnt_init (&rpc_cfg, options, this->ctx, this->name); + rpc = rpc_clnt_new(options, this, this->name, 16); + if (!rpc) + goto out; - if (rpc) { - ret = rpc_clnt_register_notify (rpc, cli_rpc_notify, this); - } + ret = rpc_clnt_register_notify(rpc, cli_rpc_notify, this); + if (ret) { + gf_log("cli", GF_LOG_ERROR, "failed to register notify"); + goto out; + } + + ret = rpc_clnt_start(rpc); out: - return rpc; + if (options) + dict_unref(options); + + if (ret) { + if (rpc) + rpc_clnt_unref(rpc); + rpc = NULL; + } + return rpc; } cli_local_t * -cli_local_get () +cli_local_get() { - cli_local_t *local = NULL; + cli_local_t *local = NULL; - local = GF_CALLOC (1, sizeof (*local), cli_mt_cli_local_t); + local = GF_CALLOC(1, sizeof(*local), cli_mt_cli_local_t); + LOCK_INIT(&local->lock); + INIT_LIST_HEAD(&local->dict_list); - return local; + return local; } void -cli_local_wipe (cli_local_t *local) +cli_local_wipe(cli_local_t *local) { - if (local) { - GF_FREE (local); - } - - return; + if (local) { + GF_FREE(local->get_vol.volname); + if (local->dict) + dict_unref(local->dict); + GF_FREE(local); + } + + return; } struct cli_state *global_state; int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - struct cli_state state = {0, }; - int ret = -1; - glusterfs_ctx_t *ctx = NULL; + struct cli_state state = { + 0, + }; + int ret = -1; + glusterfs_ctx_t *ctx = NULL; - if (geteuid ()) { - printf ("Only super user can run this command\n"); - return EPERM; - } + mem_pools_init(); - ret = glusterfs_globals_init (); - if (ret) - return ret; + ctx = glusterfs_ctx_new(); + if (!ctx) + return ENOMEM; - ctx = glusterfs_ctx_get (); - if (!ctx) - return ENOMEM; +#ifdef DEBUG + gf_mem_acct_enable_set(ctx); +#endif - ret = glusterfs_ctx_defaults_init (ctx); - if (ret) - goto out; + ret = glusterfs_globals_init(ctx); + if (ret) + return ret; - ret = cli_state_init (&state); - if (ret) - goto out; + THIS->ctx = ctx; - global_rpc = cli_rpc_init (&state); - if (!global_rpc) - goto out; + ret = glusterfs_ctx_defaults_init(ctx); + if (ret) + goto out; - state.ctx = ctx; - global_state = &state; + cli_default_conn_timeout = 120; + cli_ten_minutes_timeout = 600; - ret = parse_cmdline (argc, argv, &state); - if (ret) - goto out; + ret = cli_state_init(&state); + if (ret) + goto out; - ret = logging_init (ctx); - if (ret) - goto out; + state.ctx = ctx; + global_state = &state; - ret = cli_cmds_register (&state); - if (ret) - goto out; + ret = parse_cmdline(argc, argv, &state); + if (ret) + goto out; - ret = cli_cmd_cond_init (); - if (ret) - goto out; + ret = logging_init(ctx, &state); + if (ret) + goto out; - ret = cli_input_init (&state); - if (ret) - goto out; + gf_log("cli", GF_LOG_INFO, "Started running %s with version %s", argv[0], + PACKAGE_VERSION); + + global_rpc = cli_rpc_init(&state); + if (!global_rpc) + goto out; + + global_quotad_rpc = cli_quotad_clnt_rpc_init(); + if (!global_quotad_rpc) + goto out; - ret = event_dispatch (ctx->event_pool); + ret = cli_cmds_register(&state); + if (ret) + goto out; + + ret = cli_input_init(&state); + if (ret) + goto out; + + ret = gf_event_dispatch(ctx->event_pool); out: -// glusterfs_ctx_destroy (ctx); + // glusterfs_ctx_destroy (ctx); - return ret; + mem_pools_fini(); + + return ret; +} + +void +cli_print_line(int len) +{ + GF_ASSERT(len > 0); + + while (len--) + printf("-"); + + printf("\n"); +} + +void +print_quota_list_header(int type) +{ + if (type == GF_QUOTA_OPTION_TYPE_LIST) { + cli_out( + " Path Hard-limit " + " Soft-limit Used Available Soft-limit " + "exceeded? Hard-limit exceeded?"); + cli_out( + "-----------------------------------------------------" + "-----------------------------------------------------" + "---------------------"); + } else { + cli_out( + " Path Hard-limit " + " Soft-limit Files Dirs Available " + "Soft-limit exceeded? Hard-limit exceeded?"); + cli_out( + "-----------------------------------------------------" + "-----------------------------------------------------" + "-------------------------------------"); + } +} + +void +print_quota_list_empty(char *path, int type) +{ + if (type == GF_QUOTA_OPTION_TYPE_LIST) + cli_out("%-40s %7s %9s %10s %7s %15s %20s", path, "N/A", "N/A", "N/A", + "N/A", "N/A", "N/A"); + else + cli_out("%-40s %9s %9s %12s %10s %10s %15s %20s", path, "N/A", "N/A", + "N/A", "N/A", "N/A", "N/A", "N/A"); } |