Example #1
0
static int
xlator_option_validate_double (xlator_t *xl, const char *key, const char *value,
                               volume_option_t *opt, char **op_errstr)
{
        double    input = 0.0;
        int       ret = -1;
        char      errstr[256];

        /* Check the range */
        if (gf_string2double (value, &input) != 0) {
                snprintf (errstr, 256,
                          "invalid number format \"%s\" in option \"%s\"",
                          value, key);
                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s",
                        errstr);
                goto out;
        }

        if ((opt->min == 0) && (opt->max == 0) &&
            (opt->validate == GF_OPT_VALIDATE_BOTH)) {
                gf_msg_trace (xl->name, 0, "no range check required for "
                              "'option %s %s'", key, value);
                ret = 0;
                goto out;
        }

        if (opt->validate == GF_OPT_VALIDATE_MIN) {
                if (input < opt->min) {
                        snprintf (errstr, 256,
                                  "'%f' in 'option %s %s' is smaller than "
                                  "minimum value '%f'", input, key,
                                  value, opt->min);
                        gf_msg (xl->name, GF_LOG_ERROR, 0,
                                LG_MSG_INVALID_ENTRY, "%s", errstr);
                        goto out;
                }
        } else if (opt->validate == GF_OPT_VALIDATE_MAX) {
                if (input > opt->max) {
                        snprintf (errstr, 256,
                                  "'%f' in 'option %s %s' is greater than "
                                  "maximum value '%f'", input, key,
                                  value, opt->max);
                        gf_msg (xl->name, GF_LOG_ERROR, 0,
                                LG_MSG_INVALID_ENTRY, "%s", errstr);
                        goto out;
                }
        } else if ((input < opt->min) || (input > opt->max)) {
                snprintf (errstr, 256,
                          "'%f' in 'option %s %s' is out of range "
                          "[%f - %f]",
                          input, key, value, opt->min, opt->max);
                gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s",
                        errstr);
                goto out;
        }

        ret = 0;
out:
        if (ret && op_errstr)
                *op_errstr = gf_strdup (errstr);
        return ret;
}
Example #2
0
static error_t
parse_opts (int key, char *arg, struct argp_state *state)
{
    cmd_args_t   *cmd_args      = NULL;
    uint32_t      n             = 0;
    double        d             = 0.0;
    gf_boolean_t  b             = _gf_false;
    char         *pwd           = NULL;
    char          tmp_buf[2048] = {0,};

    cmd_args = state->input;

    switch (key) {
    case ARGP_VOLFILE_SERVER_KEY:
        cmd_args->volfile_server = gf_strdup (arg);
        break;

    case ARGP_VOLFILE_MAX_FETCH_ATTEMPTS:
        n = 0;

        if (gf_string2uint_base10 (arg, &n) == 0) {
            cmd_args->max_connect_attempts = n;
            break;
        }

        argp_failure (state, -1, 0,
                      "Invalid limit on connect attempts %s", arg);
        break;

    case ARGP_READ_ONLY_KEY:
        cmd_args->read_only = 1;
        break;

    case ARGP_MAC_COMPAT_KEY:
        if (!arg)
            arg = "on";

        if (gf_string2boolean (arg, &b) == 0) {
            cmd_args->mac_compat = b;

            break;
        }

        argp_failure (state, -1, 0,
                      "invalid value \"%s\" for mac-compat", arg);
        break;

    case ARGP_VOLUME_FILE_KEY:
        if (cmd_args->volfile)
            GF_FREE (cmd_args->volfile);

        if (arg[0] != '/') {
            pwd = getcwd (NULL, PATH_MAX);
            if (!pwd) {
                argp_failure (state, -1, errno,
                              "getcwd failed with error no %d",
                              errno);
                break;
            }
            snprintf (tmp_buf, 1024, "%s/%s", pwd, arg);
            cmd_args->volfile = gf_strdup (tmp_buf);
            free (pwd);
        } else {
            cmd_args->volfile = gf_strdup (arg);
        }

        break;

    case ARGP_LOG_SERVER_KEY:
        if (cmd_args->log_server)
            GF_FREE (cmd_args->log_server);

        cmd_args->log_server = gf_strdup (arg);
        break;

    case ARGP_LOG_LEVEL_KEY:
        if (strcasecmp (arg, ARGP_LOG_LEVEL_NONE_OPTION) == 0) {
            cmd_args->log_level = GF_LOG_NONE;
            break;
        }
        if (strcasecmp (arg, ARGP_LOG_LEVEL_CRITICAL_OPTION) == 0) {
            cmd_args->log_level = GF_LOG_CRITICAL;
            break;
        }
        if (strcasecmp (arg, ARGP_LOG_LEVEL_ERROR_OPTION) == 0) {
            cmd_args->log_level = GF_LOG_ERROR;
            break;
        }
        if (strcasecmp (arg, ARGP_LOG_LEVEL_WARNING_OPTION) == 0) {
            cmd_args->log_level = GF_LOG_WARNING;
            break;
        }
        if (strcasecmp (arg, ARGP_LOG_LEVEL_NORMAL_OPTION) == 0) {
            cmd_args->log_level = GF_LOG_NORMAL;
            break;
        }
        if (strcasecmp (arg, ARGP_LOG_LEVEL_DEBUG_OPTION) == 0) {
            cmd_args->log_level = GF_LOG_DEBUG;
            break;
        }
        if (strcasecmp (arg, ARGP_LOG_LEVEL_TRACE_OPTION) == 0) {
            cmd_args->log_level = GF_LOG_TRACE;
            break;
        }

        argp_failure (state, -1, 0, "unknown log level %s", arg);
        break;

    case ARGP_LOG_FILE_KEY:
        cmd_args->log_file = gf_strdup (arg);
        break;

    case ARGP_VOLFILE_SERVER_PORT_KEY:
        n = 0;

        if (gf_string2uint_base10 (arg, &n) == 0) {
            cmd_args->volfile_server_port = n;
            break;
        }

        argp_failure (state, -1, 0,
                      "unknown volfile server port %s", arg);
        break;

    case ARGP_LOG_SERVER_PORT_KEY:
        n = 0;

        if (gf_string2uint_base10 (arg, &n) == 0) {
            cmd_args->log_server_port = n;
            break;
        }

        argp_failure (state, -1, 0,
                      "unknown log server port %s", arg);
        break;

    case ARGP_VOLFILE_SERVER_TRANSPORT_KEY:
        cmd_args->volfile_server_transport = gf_strdup (arg);
        break;

    case ARGP_VOLFILE_ID_KEY:
        cmd_args->volfile_id = gf_strdup (arg);
        break;

    case ARGP_PID_FILE_KEY:
        cmd_args->pid_file = gf_strdup (arg);
        break;

    case ARGP_NO_DAEMON_KEY:
        cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
        break;

    case ARGP_RUN_ID_KEY:
        cmd_args->run_id = gf_strdup (arg);
        break;

    case ARGP_DEBUG_KEY:
        cmd_args->debug_mode = ENABLE_DEBUG_MODE;
        break;

    case ARGP_DIRECT_IO_MODE_KEY:
        if (!arg)
            arg = "on";

        if (gf_string2boolean (arg, &b) == 0) {
            cmd_args->fuse_direct_io_mode = b;

            break;
        }

        argp_failure (state, -1, 0,
                      "unknown direct I/O mode setting \"%s\"", arg);
        break;

    case ARGP_ENTRY_TIMEOUT_KEY:
        d = 0.0;

        gf_string2double (arg, &d);
        if (!(d < 0.0)) {
            cmd_args->fuse_entry_timeout = d;
            break;
        }

        argp_failure (state, -1, 0, "unknown entry timeout %s", arg);
        break;

    case ARGP_ATTRIBUTE_TIMEOUT_KEY:
        d = 0.0;

        gf_string2double (arg, &d);
        if (!(d < 0.0)) {
            cmd_args->fuse_attribute_timeout = d;
            break;
        }

        argp_failure (state, -1, 0,
                      "unknown attribute timeout %s", arg);
        break;

    case ARGP_CLIENT_PID_KEY:
        if (gf_string2int (arg, &cmd_args->client_pid) == 0) {
            cmd_args->client_pid_set = 1;
            break;
        }

        argp_failure (state, -1, 0,
                      "unknown client pid %s", arg);
        break;

    case ARGP_VOLFILE_CHECK_KEY:
        cmd_args->volfile_check = 1;
        break;

    case ARGP_VOLUME_NAME_KEY:
        cmd_args->volume_name = gf_strdup (arg);
        break;

    case ARGP_XLATOR_OPTION_KEY:
        gf_remember_xlator_option (&cmd_args->xlator_options, arg);
        break;

    case ARGP_KEY_NO_ARGS:
        break;

    case ARGP_KEY_ARG:
        if (state->arg_num >= 1)
            argp_usage (state);

        cmd_args->mount_point = gf_strdup (arg);
        break;

    case ARGP_DUMP_FUSE_KEY:
        cmd_args->dump_fuse = gf_strdup (arg);
        break;
    case ARGP_BRICK_NAME_KEY:
        cmd_args->brick_name = gf_strdup (arg);
        break;
    case ARGP_BRICK_PORT_KEY:
        n = 0;

        if (gf_string2uint_base10 (arg, &n) == 0) {
            cmd_args->brick_port = n;
            break;
        }

        argp_failure (state, -1, 0,
                      "unknown brick (listen) port %s", arg);
        break;
    }

    return 0;
}