libgfapi: Added support to fetch volume info from glusterd and store in glfs object.

Defined new APIs in the libgfapi module, given a glfs object,
 * to send handshake RPC call to glusterd process to fetch UUID of the volume
 * store it in the glusterfs_context linked to the glfs object.
 * to parse UUID from its cannonical string format into 16-byte array
   before sending it to the libgfapi users.

Defined a RPC call in glusterd which can be used to query volume related
info by other processes using 'clnt_handshake_procs'.

Note - Currently this RPC call to glusterd process is used only to fetch UUID.
But it can be extended to get other volume related structures as well.

In addition to the above, defined a new variable to keep track of such handshake
RPCs still in progress to make sure all the corresponding RPC callbacks have been
processed before libgfapi returns the glfs object initialized.

Also bumping up the GFAPI current version number since there is a new API
"glfs_get_volume_id" defined and exposed by libgfapi as part of these changes.

Cherry picked from commit 5adb10b9ac1c634334f29732e062b12d747ae8c5:
> Change-Id: I303f76d7177d32d25bdb301b1dbcf5cd73f42807
> BUG: 1095775
> Signed-off-by: Soumya Koduri <skoduri@redhat.com>
> Reviewed-on: http://review.gluster.org/7218
> Reviewed-by: Anand Avati <avati@redhat.com>
> Reviewed-by: Harshavardhana <harsha@harshavardhana.net>
> Tested-by: Gluster Build System <jenkins@build.gluster.com>
> Reviewed-by: Vijay Bellur <vbellur@redhat.com>

This change differs a little from the patch in the master branch:
- libgfapi in 3.5 does not have glfs_get_volfile(), so there were some
  merge conflicts resolved,
- libgfapi in 3.5 is not versioned, the configure.ac changes related to
  the versioning have been skipped,
- in the master branch only the XDR .x files are available, release-3.5
  requires a manual re-generation of the relates .h and .c files.

Change-Id: I52c32d0e69a52a7f4285f74164bca6fd83c4f3b3
BUG: 1095775
Signed-off-by: Soumya Koduri <skoduri@redhat.com>
Reviewed-on: http://review.gluster.org/7741
Reviewed-by: Niels de Vos <ndevos@redhat.com>
Tested-by: Niels de Vos <ndevos@redhat.com>

1 files changed, 137 insertions, 0 deletions

diff --git a/xlators/mgmt/glusterd/src/glusterd-handshake.c b/xlators/mgmt/glusterd/src/glusterd-handshake.c
index 1420eb692ee..87958d0701b 100644
--- a/xlators/mgmt/glusterd/src/glusterd-handshake.c
+++ b/xlators/mgmt/glusterd/src/glusterd-handshake.c
@@ -591,10 +591,147 @@ glusterd_mgmt_hndsk_versions_ack (rpcsvc_request_t *req)
                                             __glusterd_mgmt_hndsk_versions_ack);
 }
 
+int
+__server_get_volume_info (rpcsvc_request_t *req)
+{
+        int                     ret             = -1;
+        int32_t                 op_errno        = ENOENT;
+        gf_get_volume_info_req	vol_info_req    = {{0,}};
+        gf_get_volume_info_rsp	vol_info_rsp    = {0,};
+        char                    *volname        = NULL;
+        glusterd_volinfo_t      *volinfo        = NULL;
+        dict_t                  *dict           = NULL;
+        dict_t                  *dict_rsp       = NULL;
+        char                    *volume_id_str  = NULL;
+        int32_t                 flags           = 0;
+
+        ret = xdr_to_generic (req->msg[0], &vol_info_req,
+                             (xdrproc_t)xdr_gf_get_volume_info_req);
+        if (ret < 0) {
+                //failed to decode msg;
+                req->rpc_err = GARBAGE_ARGS;
+                goto out;
+        }
+        gf_log ("glusterd", GF_LOG_INFO, "Received get volume info req");
+
+        if (vol_info_req.dict.dict_len) {
+                /* Unserialize the dictionary */
+                dict  = dict_new ();
+                if (!dict) {
+                        gf_log ("", GF_LOG_WARNING, "Out of Memory");
+                        op_errno = ENOMEM;
+                        ret = -1;
+                        goto out;
+                }
+
+                ret = dict_unserialize (vol_info_req.dict.dict_val,
+                                        vol_info_req.dict.dict_len,
+                                        &dict);
+                if (ret < 0) {
+                        gf_log ("glusterd", GF_LOG_ERROR,
+                                "failed to "
+                                "unserialize req-buffer to dictionary");
+                        op_errno = -ret;
+                        ret = -1;
+                        goto out;
+                } else {
+                        dict->extra_stdfree = vol_info_req.dict.dict_val;
+                }
+        }
+
+        ret = dict_get_int32 (dict, "flags", &flags);
+        if (ret) {
+                gf_log (THIS->name, GF_LOG_ERROR, "failed to get flags");
+                op_errno = -ret;
+                ret = -1;
+                goto out;
+        }
+
+        if (!flags) {
+                //Nothing to query about. Just return success
+                gf_log (THIS->name, GF_LOG_ERROR, "No flags set");
+                ret = 0;
+                goto out;
+        }
+
+        ret = dict_get_str (dict, "volname", &volname);
+        if (ret) {
+                op_errno = EINVAL;
+                ret = -1;
+                goto out;
+        }
+
+        ret = glusterd_volinfo_find (volname, &volinfo);
+        if (ret) {
+                op_errno = EINVAL;
+                ret = -1;
+                goto out;
+        }
+
+        if (flags | (int32_t)GF_GET_VOLUME_UUID) {
+                volume_id_str = gf_strdup (uuid_utoa (volinfo->volume_id));
+                if (!volume_id_str) {
+                        op_errno = ENOMEM;
+                        ret = -1;
+                        goto out;
+                }
+
+                dict_rsp = dict_new ();
+                if (!dict_rsp) {
+                        gf_log ("", GF_LOG_WARNING, "Out of Memory");
+                        op_errno = ENOMEM;
+                        ret = -1;
+                        goto out;
+                }
+                ret = dict_set_dynstr (dict_rsp, "volume_id", volume_id_str);
+                if (ret) {
+                        op_errno = -ret;
+                        ret = -1;
+                        goto out;
+                }
+        }
+        ret = dict_allocate_and_serialize (dict_rsp, &vol_info_rsp.dict.dict_val,
+                                           &vol_info_rsp.dict.dict_len);
+        if (ret) {
+                op_errno = -ret;
+                ret = -1;
+                goto out;
+        }
+
+out:
+        vol_info_rsp.op_ret = ret;
+        vol_info_rsp.op_errno = op_errno;
+        vol_info_rsp.op_errstr = "";
+        glusterd_submit_reply (req, &vol_info_rsp, NULL, 0, NULL,
+                               (xdrproc_t)xdr_gf_get_volume_info_rsp);
+        ret = 0;
+
+        if (dict) {
+                dict_unref (dict);
+        }
+
+        if (dict_rsp) {
+                dict_unref (dict_rsp);
+        }
+
+        if (vol_info_rsp.dict.dict_val) {
+                GF_FREE (vol_info_rsp.dict.dict_val);
+        }
+        return ret;
+}
+
+int
+server_get_volume_info (rpcsvc_request_t *req)
+{
+        return glusterd_big_locked_handler (req,
+                                            __server_get_volume_info);
+}
+
 rpcsvc_actor_t gluster_handshake_actors[] = {
         [GF_HNDSK_NULL]         = {"NULL",        GF_HNDSK_NULL,         NULL,                NULL, 0, DRC_NA},
         [GF_HNDSK_GETSPEC]      = {"GETSPEC",     GF_HNDSK_GETSPEC,      server_getspec,      NULL, 0, DRC_NA},
         [GF_HNDSK_EVENT_NOTIFY] = {"EVENTNOTIFY", GF_HNDSK_EVENT_NOTIFY, server_event_notify, NULL, 0, DRC_NA},
+        [GF_HNDSK_GET_VOLUME_INFO] = {"GETVOLUMEINFO", GF_HNDSK_GET_VOLUME_INFO, server_get_volume_info, NULL, 0, DRC_NA},
 };