!128 Support inspect graph driver's metadata

Merge pull request !128 from wangfengtu/driver_metadata

src/api/image_client/isula_image.proto

@@ -78,6 +78,9 @@ service ImageService {
     // get status of graphdriver
     rpc GraphdriverStatus(GraphdriverStatusRequest) returns (GraphdriverStatusResponse) {}
 
+    // get metadata of graphdriver
+    rpc GraphdriverMetadata(GraphdriverMetadataRequest) returns (GraphdriverMetadataResponse) {}
+
     // login registry
     rpc Login(LoginRequest) returns (LoginResponse) {}
     // logout registry
@@ -146,6 +149,17 @@ message GraphdriverStatusResponse {
     uint32 cc = 3;
 }
 
+message GraphdriverMetadataRequest {
+    string name_id = 1;
+}
+
+message GraphdriverMetadataResponse {
+    map<string,string> metadata = 1;
+    string name = 2;
+    string errmsg = 3;
+    uint32 cc = 4;
+}
+
 message ContainerFsUsageRequest {
     string name_id = 1;
 }

src/connect/client/grpc/grpc_isula_image_client.cc

@@ -875,6 +875,63 @@ public:
     }
 };
 
+class ISulaStorageMetadata : public
+    ClientBase<isula::ImageService, isula::ImageService::Stub, isula_storage_metadata_request,
+    isula::GraphdriverMetadataRequest, isula_storage_metadata_response, isula::GraphdriverMetadataResponse> {
+public:
+    explicit ISulaStorageMetadata(void *args) : ClientBase(args)
+    {
+    }
+    ~ISulaStorageMetadata() = default;
+
+    int request_to_grpc(const isula_storage_metadata_request *req, isula::GraphdriverMetadataRequest *grequest) override
+    {
+        if (req == nullptr) {
+            isulad_set_error_message("unvalid export request");
+            return -1;
+        }
+        if (req->container_id != nullptr) {
+            grequest->set_name_id(req->container_id);
+        }
+        return 0;
+    }
+
+    int response_from_grpc(isula::GraphdriverMetadataResponse *gresp, isula_storage_metadata_response *resp) override
+    {
+        int metadata_len = gresp->metadata_size();
+        if (metadata_len > 0) {
+            resp->metadata = (json_map_string_string *)util_common_calloc_s(sizeof(json_map_string_string));
+            if (resp->metadata == nullptr) {
+                ERROR("Out of memory");
+                return -1;
+            }
+            for (const auto &iter : gresp->metadata()) {
+                if (append_json_map_string_string(resp->metadata, iter.first.c_str(), iter.second.c_str()) != 0) {
+                    ERROR("Out of memory");
+                    return -1;
+                }
+            }
+        }
+
+        if (!gresp->name().empty()) {
+            resp->name = util_strdup_s(gresp->name().c_str());
+        }
+
+        if (!gresp->errmsg().empty()) {
+            resp->errmsg = util_strdup_s(gresp->errmsg().c_str());
+        }
+        resp->server_errono = gresp->cc();
+
+        return 0;
+    }
+
+    Status grpc_call(ClientContext *context, const isula::GraphdriverMetadataRequest &req,
+                     isula::GraphdriverMetadataResponse *reply) override
+    {
+        return stub_->GraphdriverMetadata(context, req, reply);
+    }
+};
+
 class ISulaContainerFsUsage : public
     ClientBase<isula::ImageService, isula::ImageService::Stub, isula_container_fs_usage_request,
     isula::ContainerFsUsageRequest, isula_container_fs_usage_response, isula::ContainerFsUsageResponse> {
@@ -1060,6 +1117,8 @@ int grpc_isula_image_client_ops_init(isula_image_ops *ops)
 
     ops->storage_status = container_func<isula_storage_status_request, isula_storage_status_response,
          ISulaStorageStatus>;
+    ops->storage_metadata = container_func<isula_storage_metadata_request, isula_storage_metadata_response,
+         ISulaStorageMetadata>;
 
     ops->health_check = container_func<isula_health_check_request, isula_health_check_response, ISulaHealthCheck>;
 

src/connect/client/isula_image_connect.c

@@ -470,6 +470,20 @@ void free_isula_storage_status_response(struct isula_storage_status_response *pt
     free(ptr);
 }
 
+void free_isula_storage_metadata_response(struct isula_storage_metadata_response *ptr)
+{
+    if (ptr == NULL) {
+        return;
+    }
+    free_json_map_string_string(ptr->metadata);
+    ptr->metadata = NULL;
+    free(ptr->name);
+    ptr->name = NULL;
+    free(ptr->errmsg);
+    ptr->errmsg = NULL;
+    free(ptr);
+}
+
 void free_isula_health_check_request(struct isula_health_check_request *ptr)
 {
     if (ptr == NULL) {

src/connect/client/isula_image_connect.h

@@ -230,6 +230,19 @@ struct isula_storage_status_response {
     uint32_t server_errono;
 };
 
+struct isula_storage_metadata_request {
+    char *container_id;
+};
+
+struct isula_storage_metadata_response {
+    json_map_string_string *metadata;
+    char *name;
+
+    char *errmsg;
+    uint32_t cc;
+    uint32_t server_errono;
+};
+
 struct isula_container_fs_usage_request {
     char *name_id;
 };
@@ -297,6 +310,10 @@ typedef struct {
     int (*storage_status)(const struct isula_storage_status_request *req, struct isula_storage_status_response *resp,
                           void *arg);
 
+    int (*storage_metadata)(const struct isula_storage_metadata_request *req,
+                            struct isula_storage_metadata_response *resp,
+                            void *arg);
+
     int (*health_check)(const struct isula_health_check_request *req,
                         struct isula_health_check_response *resp, void *arg);
 } isula_image_ops;
@@ -355,6 +372,8 @@ void free_isula_container_fs_usage_response(struct isula_container_fs_usage_resp
 void free_isula_storage_status_request(struct isula_storage_status_request *ptr);
 void free_isula_storage_status_response(struct isula_storage_status_response *ptr);
 
+void free_isula_storage_metadata_response(struct isula_storage_metadata_response *ptr);
+
 void free_isula_health_check_request(struct isula_health_check_request *ptr);
 void free_isula_health_check_response(struct isula_health_check_response *ptr);
 

src/image/image.c

@@ -62,6 +62,7 @@ static const struct bim_ops g_embedded_ops = {
     .container_fs_usage = embedded_filesystem_usage,
     .get_filesystem_info = NULL,
     .get_storage_status = NULL,
+    .get_storage_metadata = NULL,
     .image_status = NULL,
     .load_image = embedded_load_image,
     .pull_image = NULL,
@@ -97,6 +98,7 @@ static const struct bim_ops g_isula_ops = {
     .container_fs_usage = isula_container_filesystem_usage,
     .get_filesystem_info = isula_get_filesystem_info,
     .get_storage_status = isula_get_storage_status,
+    .get_storage_metadata = isula_get_storage_metadata,
     .image_status = oci_status_image,
     .load_image = isual_load_image,
     .pull_image = isula_pull_rf,
@@ -131,6 +133,7 @@ static const struct bim_ops g_ext_ops = {
     .image_status = NULL,
     .get_filesystem_info = NULL,
     .get_storage_status = NULL,
+    .get_storage_metadata = NULL,
     .load_image = ext_load_image,
     .pull_image = NULL,
     .login = ext_login,
@@ -322,6 +325,36 @@ out:
     return ret;
 }
 
+int im_get_storage_metadata(const char *image_type, char *id, im_storage_metadata_response **response)
+{
+    int ret = -1;
+    const struct bim_type *q = NULL;
+
+    if (image_type == NULL || response == NULL) {
+        ERROR("Image type or response is NULL");
+        goto out;
+    }
+    q = get_bim_by_type(image_type);
+    if (q == NULL) {
+        goto out;
+    }
+    if (q->ops->get_storage_metadata == NULL) {
+        ERROR("Get storage metadata umimplements");
+        goto out;
+    }
+
+    ret = q->ops->get_storage_metadata(id, response);
+    if (ret != 0) {
+        ERROR("Get storage metadata failed");
+        free_im_storage_metadata_response(*response);
+        *response = NULL;
+        goto out;
+    }
+
+out:
+    return ret;
+}
+
 int im_get_filesystem_info(const char *image_type, im_fs_info_response **response)
 {
     int ret = -1;
@@ -1803,6 +1836,20 @@ void free_im_storage_status_response(im_storage_status_response *ptr)
     free(ptr);
 }
 
+void free_im_storage_metadata_response(im_storage_metadata_response *ptr)
+{
+    if (ptr == NULL) {
+        return;
+    }
+    free_json_map_string_string(ptr->metadata);
+    ptr->metadata = NULL;
+    free(ptr->name);
+    ptr->name = NULL;
+    free(ptr->errmsg);
+    ptr->errmsg = NULL;
+    free(ptr);
+}
+
 void im_sync_containers_isuladkit(void)
 {
     DEBUG("Sync containers...");

src/image/image.h

@@ -58,6 +58,12 @@ typedef struct {
     char *status;
 } im_storage_status_response;
 
+typedef struct {
+    json_map_string_string *metadata;
+    char *name;
+    char *errmsg;
+} im_storage_metadata_response;
+
 typedef struct {
     imagetool_fs_info *fs_info;
     char *errmsg;
@@ -238,6 +244,8 @@ struct bim_ops {
 
     int (*get_storage_status)(im_storage_status_response **response);
 
+    int (*get_storage_metadata)(char *id, im_storage_metadata_response **response);
+
     /* load image */
     int (*load_image)(const im_load_request *request);
 
@@ -363,6 +371,10 @@ int im_get_storage_status(const char *image_type, im_storage_status_response **r
 
 void free_im_storage_status_response(im_storage_status_response *ptr);
 
+int im_get_storage_metadata(const char *image_type, char *id, im_storage_metadata_response **response);
+
+void free_im_storage_metadata_response(im_storage_metadata_response *ptr);
+
 size_t im_get_image_count(const im_image_count_request *request);
 
 void free_im_image_count_request(im_image_count_request *ptr);

src/image/oci/isula_image.c

@@ -36,6 +36,7 @@
 #include "isula_health_check.h"
 #include "isula_images_list.h"
 #include "isula_containers_list.h"
+#include "isula_storage_metadata.h"
 
 #include "containers_store.h"
 #include "oci_images_store.h"
@@ -348,6 +349,35 @@ err_out:
     return ret;
 }
 
+int isula_get_storage_metadata(char *id, im_storage_metadata_response **response)
+{
+    int ret = -1;
+
+    if (response == NULL || id == NULL) {
+        ERROR("Invalid input arguments");
+        return ret;
+    }
+
+    *response = (im_storage_metadata_response *)util_common_calloc_s(sizeof(im_storage_metadata_response));
+    if (*response == NULL) {
+        ERROR("Out of memory");
+        return ret;
+    }
+
+    ret = isula_do_storage_metadata(id, *response);
+    if (ret != 0) {
+        ERROR("Get get storage metadata failed");
+        ret = -1;
+        goto err_out;
+    }
+
+    return 0;
+err_out:
+    free_im_storage_metadata_response(*response);
+    *response = NULL;
+    return ret;
+}
+
 int isual_load_image(const im_load_request *request)
 {
     char **refs = NULL;

src/image/oci/isula_image.h

@@ -41,6 +41,7 @@ int isula_export_rf(const im_export_request *request);
 int isula_container_filesystem_usage(const im_container_fs_usage_request *request, imagetool_fs_info **fs_usage);
 
 int isula_get_storage_status(im_storage_status_response **response);
+int isula_get_storage_metadata(char *id, im_storage_metadata_response **response);
 
 int isula_login(const im_login_request *request);
 int isula_logout(const im_logout_request *request);

src/image/oci/isula_storage_metadata.c

+/******************************************************************************
+* Copyright (c) Huawei Technologies Co., Ltd. 2020. All rights reserved.
+ * iSulad licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *     http://license.coscl.org.cn/MulanPSL
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v1 for more details.
+* Author: liuhao
+* Create: 2020-03-24
+* Description: isula storage metadata operator implement
+*******************************************************************************/
+#include "isula_storage_metadata.h"
+
+#include "isula_image_connect.h"
+#include "isula_helper.h"
+#include "connect.h"
+#include "utils.h"
+#include "log.h"
+
+int isula_do_storage_metadata(char *id, im_storage_metadata_response *resp)
+{
+    int ret = 0;
+    int nret = -1;
+    struct isula_storage_metadata_request ireq;
+    struct isula_storage_metadata_response *iresp = NULL;
+    client_connect_config_t conf = { 0 };
+    isula_image_ops *im_ops = NULL;
+
+    if (resp == NULL || id == NULL) {
+        ERROR("Invalid arguments");
+        return -1;
+    }
+
+    im_ops = get_isula_image_ops();
+    if (im_ops == NULL) {
+        ERROR("Failed to init isula server grpc client");
+        return -1;
+    }
+    if (im_ops->storage_metadata == NULL) {
+        ERROR("Umimplement get storage metadata operator");
+        return -1;
+    }
+
+    iresp = util_common_calloc_s(sizeof(struct isula_storage_metadata_response));
+    if (iresp == NULL) {
+        ERROR("Out of memory");
+        ret = -1;
+        goto out;
+    }
+
+    nret = get_isula_image_connect_config(&conf);
+    if (nret != 0) {
+        ret = -1;
+        goto out;
+    }
+
+    ireq.container_id = id;
+    nret = im_ops->storage_metadata(&ireq, iresp, &conf);
+    if (nret != 0) {
+        ERROR("Failed to get storage metadata with error: %s", iresp->errmsg);
+        isulad_set_error_message("Failed to get storage metadata with error: %s", iresp->errmsg);
+        ret = -1;
+        goto out;
+    }
+    resp->metadata = iresp->metadata;
+    iresp->metadata = NULL;
+    resp->name = util_strdup_s(iresp->name);
+    resp->errmsg = util_strdup_s(iresp->errmsg);
+
+out:
+    free_isula_storage_metadata_response(iresp);
+    free_client_connect_config_value(&conf);
+    return ret;
+}
+

src/image/oci/isula_storage_metadata.h

+/******************************************************************************
+* Copyright (c) Huawei Technologies Co., Ltd. 2020. All rights reserved.
+ * iSulad licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *     http://license.coscl.org.cn/MulanPSL
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v1 for more details.
+* Author: liuhao
+* Create: 2020-03-23
+* Description: isula storage metadata operator implement
+*******************************************************************************/
+#ifndef __IMAGE_ISULA_STORAGE_METADATA_H
+#define __IMAGE_ISULA_STORAGE_METADATA_H
+
+#include "image.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int isula_do_storage_metadata(char *id, im_storage_metadata_response *resp);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/json/schema/schema/container/inspect.json

@@ -90,6 +90,40 @@
         "HostConfig":{
             "$ref": "../host-config.json"
         },
+        "GraphDriver":{
+            "type":"object",
+            "properties":{
+                "Data": {
+                    "type": "object",
+                    "properties": {
+                        "LowerDir":{
+                            "type":"string"
+                        },
+                        "MergedDir":{
+                            "type":"string"
+                        },
+                        "UpperDir":{
+                            "type":"string"
+                        },
+                        "WorkDir":{
+                            "type":"string"
+                        },
+                        "DeviceId":{
+                            "type":"string"
+                        },
+                        "DeviceName":{
+                            "type":"string"
+                        },
+                        "DeviceSize":{
+                            "type":"string"
+                        }
+                    }
+                },
+                "Name": {
+                    "type": "string"
+                }
+            }
+        },
         "Mounts": {
             "type": "array",
             "items": {

src/services/execution/execute/execution_information.c

@@ -199,8 +199,10 @@ static int isulad_info_cb(const host_info_request *request, host_info_response *
     struct utsname u;
     im_image_count_request *im_request = NULL;
     char *rootpath = NULL;
+#ifdef ENABLE_OCI_IMAGE
     char *graph_driver = NULL;
     struct graphdriver_status *driver_status = NULL;
+#endif
 
     DAEMON_CLEAR_ERRMSG();
 
@@ -334,8 +336,10 @@ pack_response:
         (*response)->cc = cc;
     }
     free(rootpath);
+#ifdef ENABLE_OCI_IMAGE
     free(graph_driver);
     free_graphdriver_status(driver_status);
+#endif
     free(huge_page_size);
     free(operating_system);
     free_im_image_count_request(im_request);
@@ -1339,6 +1343,15 @@ static int pack_inspect_data(const container_t *cont, container_inspect **out_in
         ret = -1;
         goto out;
     }
+
+#ifdef ENABLE_OCI_IMAGE
+    inspect->graph_driver = graphdriver_get_metadata(cont->common_config->id);
+    if (inspect->graph_driver == NULL) {
+        ret = -1;
+        goto out;
+    }
+#endif
+
 out:
     *out_inspect = inspect;
     return ret;

src/services/graphdriver/driver.c

@@ -27,8 +27,8 @@
 #include "isulad_config.h"
 #include "image.h"
 
-/* overlay2 */
-
+/* overlay/overlay2 */
+#define DRIVER_OVERLAY_NAME "overlay"
 #define DRIVER_OVERLAY2_NAME "overlay2"
 static const struct graphdriver_ops g_overlay2_ops = {
     .init = overlay2_init,
@@ -124,6 +124,77 @@ free_out:
     return status;
 }
 
+container_inspect_graph_driver *graphdriver_get_metadata(char *id)
+{
+    container_inspect_graph_driver *inspect_driver = NULL;
+    int ret = -1;
+    im_storage_metadata_response *resp = NULL;
+    int i = 0;
+
+    ret = im_get_storage_metadata(IMAGE_TYPE_OCI, id, &resp);
+    if (ret != 0) {
+        goto free_out;
+    }
+
+    if (resp->name == NULL || resp->metadata == NULL) {
+        ERROR("Failed to get metadata or name");
+        ret = -1;
+        goto free_out;
+    }
+
+    inspect_driver = util_common_calloc_s(sizeof(container_inspect_graph_driver));
+    if (inspect_driver == NULL) {
+        ERROR("Out of memory");
+        ret = -1;
+        goto free_out;
+    }
+    inspect_driver->data = util_common_calloc_s(sizeof(container_inspect_graph_driver_data));
+    if (inspect_driver->data == NULL) {
+        ERROR("Out of memory");
+        ret = -1;
+        goto free_out;
+    }
+
+    inspect_driver->name = util_strdup_s(resp->name);
+
+    if (!strcmp(resp->name, DRIVER_OVERLAY_NAME) || !strcmp(resp->name, DRIVER_OVERLAY2_NAME)) {
+        for (i = 0; i < resp->metadata->len; i++) {
+            if (!strcmp(resp->metadata->keys[i], "LowerDir")) {
+                inspect_driver->data->lower_dir = util_strdup_s(resp->metadata->values[i]);
+            } else if (!strcmp(resp->metadata->keys[i], "MergedDir")) {
+                inspect_driver->data->merged_dir = util_strdup_s(resp->metadata->values[i]);
+            } else if (!strcmp(resp->metadata->keys[i], "UpperDir")) {
+                inspect_driver->data->upper_dir = util_strdup_s(resp->metadata->values[i]);
+            } else if (!strcmp(resp->metadata->keys[i], "WorkDir")) {
+                inspect_driver->data->work_dir = util_strdup_s(resp->metadata->values[i]);
+            }
+        }
+    } else if (!strcmp(resp->name, DRIVER_DEVMAPPER_NAME)) {
+        for (i = 0; i < resp->metadata->len; i++) {
+            if (!strcmp(resp->metadata->keys[i], "DeviceId")) {
+                inspect_driver->data->device_id = util_strdup_s(resp->metadata->values[i]);
+            } else if (!strcmp(resp->metadata->keys[i], "DeviceName")) {
+                inspect_driver->data->device_name = util_strdup_s(resp->metadata->values[i]);
+            } else if (!strcmp(resp->metadata->keys[i], "DeviceSize")) {
+                inspect_driver->data->device_size = util_strdup_s(resp->metadata->values[i]);
+            }
+        }
+    } else {
+        ERROR("Unsupported driver %s", resp->name);
+        ret = -1;
+        goto free_out;
+    }
+
+    ret = 0;
+free_out:
+    free_im_storage_metadata_response(resp);
+    if (ret != 0) {
+        free_container_inspect_graph_driver(inspect_driver);
+        return NULL;
+    }
+    return inspect_driver;
+}
+
 int update_graphdriver_status(struct graphdriver **driver)
 {
     struct graphdriver_status *status = NULL;

src/services/graphdriver/driver.h

@@ -18,6 +18,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include "container_inspect.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -50,6 +51,8 @@ struct graphdriver *graphdriver_get(const char *name);
 
 struct graphdriver_status *graphdriver_get_status(void);
 
+container_inspect_graph_driver *graphdriver_get_metadata(char *id);
+
 int update_graphdriver_status(struct graphdriver **driver);
 
 void graphdriver_umount_mntpoint(void);