/*
  CLI for BD translator

  Copyright IBM, Corp. 2012

  This file is part of GlusterFS.

  Author:
  M. Mohan Kumar <mohan@in.ibm.com>

  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.
*/

#ifndef _CONFIG_H
#define _CONFIG_H
#include "config.h"
#endif

#include "cli.h"
#include "cli-cmd.h"
#include <string.h>

extern rpc_clnt_prog_t *cli_rpc_prog;

int
cli_cmd_bd_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
                      const char **words, int wordcount);

int32_t
cli_cmd_bd_parse (dict_t *dict, const char **words)
{
        char          *volname  = NULL;
        char          *buff     = NULL;
        char          *buffp    = NULL;
        int            ret      = -1;
        char          *save     = NULL;
        char          *path     = NULL;
        char          *size     = NULL;
        char          *eptr     = NULL;
        gf_xl_bd_op_t  bd_op    = GF_BD_OP_INVALID;
        char          *dest_lv  = NULL;


        /* volname:/path */
        if (!strchr (words[2], ':') || !strchr (words[2], '/')) {
                cli_out ("invalid parameter %s, needs <volname:/path>",
                                words[2]);
                return -1;
        }
        buff = buffp = gf_strdup (words[2]);
        volname = strtok_r (buff, ":", &save);
        path = strtok_r (NULL, ":", &save);

        ret = dict_set_dynstr (dict, "volname", gf_strdup (volname));
        if (ret)
                goto out;

        ret = dict_set_dynstr (dict, "path", gf_strdup (path));
        if (ret)
                goto out;

        if (!strcasecmp (words[1], "create"))
                bd_op = GF_BD_OP_NEW_BD;
        else if (!strcasecmp (words[1], "delete"))
                bd_op = GF_BD_OP_DELETE_BD;
        else if (!strcasecmp (words[1], "clone"))
                bd_op = GF_BD_OP_CLONE_BD;
        else if (!strcasecmp (words[1], "snapshot"))
                bd_op = GF_BD_OP_SNAPSHOT_BD;
        else
                return -1;

        ret = dict_set_int32 (dict, "bd-op", bd_op);
        if (ret)
                goto out;

        if (bd_op == GF_BD_OP_NEW_BD) {
                /* If no suffix given we will treat it as MB */
                strtoull (words[3], &eptr, 0);
                /* no suffix */
                if (!eptr[0])
                        gf_asprintf (&size, "%sMB", words[3]);
                else
                        size = gf_strdup (words[3]);

                ret = dict_set_dynstr (dict, "size", size);
                if (ret)
                        goto out;
        } else if (bd_op == GF_BD_OP_SNAPSHOT_BD ||
                   bd_op == GF_BD_OP_CLONE_BD) {
                /*
                 * dest_lv should be just dest_lv, we don't support
                 * cloning/snapshotting to a different volume or vg
                 */
                if (strchr (words[3], ':') || strchr (words[3], '/')) {
                        cli_err ("invalid parameter %s, volname/vg not needed",
                                 words[3]);
                        ret = -1;
                        goto out;
                }
                dest_lv = gf_strdup (words[3]);
                ret = dict_set_dynstr (dict, "dest_lv", dest_lv);
                if (ret)
                        goto out;

                /* clone needs size as parameter */
                if (bd_op == GF_BD_OP_SNAPSHOT_BD) {
                        ret = dict_set_dynstr (dict, "size",
                                               gf_strdup (words[4]));
                        if (ret)
                                goto out;
                }
        }

        ret = 0;
out:
        GF_FREE (buffp);
        return ret;
}

/*
 * bd create <volname>:/path <size>
 * bd delete <volname>:/path
 * bd clone <volname>:/path <newbd>
 * bd snapshot <volname>:/<path> <newbd> <size>
 */
int32_t
cli_cmd_bd_validate (const char **words, int wordcount, dict_t **options)
{
        dict_t  *dict = NULL;
        int     ret   = -1;
        char    *op[] = { "create", "delete", "clone", "snapshot", NULL };
        int     index = 0;

        for (index = 0; op[index]; index++)
                if (!strcasecmp (words[1], op[index]))
                        break;

        if (!op[index])
                return -1;

        dict = dict_new ();
        if (!dict)
                goto out;

        if (!strcasecmp (words[1], "create")) {
                if (wordcount != 4)
                        goto out;
        } else if (!strcasecmp (words[1], "delete")) {
                if (wordcount != 3)
                        goto out;
        } else if (!strcasecmp (words[1], "clone")) {
                if (wordcount != 4)
                        goto out;
        } else if (!strcasecmp (words[1], "snapshot")) {
                if (wordcount != 5)
                        goto out;
        } else {
                ret = -1;
                goto out;
        }

        ret = cli_cmd_bd_parse (dict, words);
        if (ret < 0)
                goto out;

        *options = dict;
        ret = 0;
out:
        if (ret)
                dict_unref (dict);
        return ret;
}

int
cli_cmd_bd_cbk (struct cli_state *state, struct cli_cmd_word *word,
                         const char **words, int wordcount)
{
        int                     ret         = -1;
        rpc_clnt_procedure_t    *proc       = NULL;
        call_frame_t            *frame      = NULL;
        int                     sent        = 0;
        int                     parse_error = 0;
        dict_t                  *options    = NULL;
        cli_local_t             *local = NULL;

        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_BD_OP];

        frame = create_frame (THIS, THIS->ctx->pool);
        if (!frame)
                goto out;

        ret = cli_cmd_bd_validate (words, wordcount, &options);
        if (ret) {
                cli_usage_out (word->pattern);
                parse_error = 1;
                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 ("BD op failed!");
        }

        CLI_STACK_DESTROY (frame);

        return ret;
}

struct cli_cmd cli_bd_cmds[] = {
        { "bd help",
           cli_cmd_bd_help_cbk,
           "display help for bd command"},
        { "bd create <volname>:<bd> <size>",
          cli_cmd_bd_cbk,
          "\n\tcreate a block device where size can be "
          "suffixed with KB, MB etc. Default size is in MB"},
        { "bd delete <volname>:<bd>",
          cli_cmd_bd_cbk,
          "Delete a block device"},
        { "bd clone <volname>:<bd> <newbd>",
          cli_cmd_bd_cbk,
          "clone device"},
        { "bd snapshot <volname>:<bd> <newbd> <size>",
          cli_cmd_bd_cbk,
          "\n\tsnapshot device where size can be "
          "suffixed with KB, MB etc. Default size is in MB"},
        { NULL, NULL, NULL }
};

int
cli_cmd_bd_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
                      const char **words, int wordcount)
{
        struct cli_cmd *cmd = NULL;

        for (cmd = cli_bd_cmds; cmd->pattern; cmd++)
                if (_gf_false == cmd->disable)
                        cli_out ("%s - %s", cmd->pattern, cmd->desc);

        return 0;
}

int
cli_cmd_bd_register (struct cli_state *state)
{
        int  ret = 0;
        struct cli_cmd *cmd = NULL;

        for (cmd = cli_bd_cmds; cmd->pattern; cmd++) {
                ret = cli_cmd_register (&state->tree, cmd);
                if (ret)
                        goto out;
        }
out:
        return ret;
}
 id='n97' href='#n97'>97</a>
<a id='n98' href='#n98'>98</a>
<a id='n99' href='#n99'>99</a>
<a id='n100' href='#n100'>100</a>
<a id='n101' href='#n101'>101</a>
<a id='n102' href='#n102'>102</a>
<a id='n103' href='#n103'>103</a>
<a id='n104' href='#n104'>104</a>
<a id='n105' href='#n105'>105</a>
<a id='n106' href='#n106'>106</a>
<a id='n107' href='#n107'>107</a>
<a id='n108' href='#n108'>108</a>
<a id='n109' href='#n109'>109</a>
<a id='n110' href='#n110'>110</a>
<a id='n111' href='#n111'>111</a>
<a id='n112' href='#n112'>112</a>
<a id='n113' href='#n113'>113</a>
<a id='n114' href='#n114'>114</a>
<a id='n115' href='#n115'>115</a>
<a id='n116' href='#n116'>116</a>
<a id='n117' href='#n117'>117</a>
<a id='n118' href='#n118'>118</a>
<a id='n119' href='#n119'>119</a>
<a id='n120' href='#n120'>120</a>
<a id='n121' href='#n121'>121</a>
<a id='n122' href='#n122'>122</a>
<a id='n123' href='#n123'>123</a>
<a id='n124' href='#n124'>124</a>
<a id='n125' href='#n125'>125</a>
<a id='n126' href='#n126'>126</a>
<a id='n127' href='#n127'>127</a>
<a id='n128' href='#n128'>128</a>
<a id='n129' href='#n129'>129</a>
<a id='n130' href='#n130'>130</a>
<a id='n131' href='#n131'>131</a>
<a id='n132' href='#n132'>132</a>
<a id='n133' href='#n133'>133</a>
<a id='n134' href='#n134'>134</a>
<a id='n135' href='#n135'>135</a>
<a id='n136' href='#n136'>136</a>
<a id='n137' href='#n137'>137</a>
<a id='n138' href='#n138'>138</a>
<a id='n139' href='#n139'>139</a>
<a id='n140' href='#n140'>140</a>
<a id='n141' href='#n141'>141</a>
<a id='n142' href='#n142'>142</a>
<a id='n143' href='#n143'>143</a>
<a id='n144' href='#n144'>144</a>
<a id='n145' href='#n145'>145</a>
<a id='n146' href='#n146'>146</a>
<a id='n147' href='#n147'>147</a>
<a id='n148' href='#n148'>148</a>
<a id='n149' href='#n149'>149</a>
<a id='n150' href='#n150'>150</a>
<a id='n151' href='#n151'>151</a>
<a id='n152' href='#n152'>152</a>
<a id='n153' href='#n153'>153</a>
<a id='n154' href='#n154'>154</a>
<a id='n155' href='#n155'>155</a>
<a id='n156' href='#n156'>156</a>
<a id='n157' href='#n157'>157</a>
<a id='n158' href='#n158'>158</a>
<a id='n159' href='#n159'>159</a>
<a id='n160' href='#n160'>160</a>
<a id='n161' href='#n161'>161</a>
<a id='n162' href='#n162'>162</a>
<a id='n163' href='#n163'>163</a>
<a id='n164' href='#n164'>164</a>
</pre></td>
<td class='lines'><pre><code>