From 343be112a3d5cfd3857f166fb5dc2473534e64d7 Mon Sep 17 00:00:00 2001
From: zhongtao <zhongtao17@huawei.com>
Date: Thu, 15 Aug 2024 15:19:25 +0800
Subject: [PATCH 122/149] [nri] impl for nri plugin and adaption

Signed-off-by: zhongtao <zhongtao17@huawei.com>
---
 src/cmd/isulad/main.c                         |   15 +
 src/daemon/common/nri/nri_convert.cc          |  148 ++-
 src/daemon/common/nri/nri_convert.h           |    7 +-
 src/daemon/common/nri/nri_spec.c              |  223 +++-
 src/daemon/common/nri/nri_spec.h              |    6 +
 src/daemon/common/nri/nri_utils.c             |  476 +++----
 src/daemon/common/nri/nri_utils.h             |   14 +-
 src/daemon/config/isulad_config.c             |    2 +-
 .../v1/v1_cri_container_manager_service.cc    |  104 +-
 .../v1/v1_cri_pod_sandbox_manager_service.cc  |   37 +-
 .../executor/container_cb/execution_create.c  |   21 +
 .../modules/service/service_container.c       |   12 +
 src/daemon/modules/spec/specs.c               |    7 +-
 src/daemon/nri/nri_adaption.cc                | 1165 +++++++++++++++++
 src/daemon/nri/nri_adaption.h                 |   13 +-
 src/daemon/nri/nri_helpers.cc                 |   21 +
 src/daemon/nri/nri_helpers.h                  |    4 +
 src/daemon/nri/nri_plugin_ops.cc              |  123 ++
 src/daemon/nri/nri_plugin_ops.h               |    6 +-
 src/daemon/nri/nri_result.cc                  |  977 ++++++++++++++
 src/daemon/nri/nri_result.h                   |   17 +-
 src/daemon/nri/plugin.cc                      |  417 ++++++
 src/daemon/nri/plugin.h                       |   20 +-
 src/utils/cutils/utils.c                      |    2 +-
 24 files changed, 3527 insertions(+), 310 deletions(-)
 create mode 100644 src/daemon/nri/nri_adaption.cc
 create mode 100644 src/daemon/nri/nri_plugin_ops.cc
 create mode 100644 src/daemon/nri/nri_result.cc
 create mode 100644 src/daemon/nri/plugin.cc

diff --git a/src/cmd/isulad/main.c b/src/cmd/isulad/main.c
index 52ac3172..0228caa8 100644
--- a/src/cmd/isulad/main.c
+++ b/src/cmd/isulad/main.c
@@ -86,6 +86,9 @@
 #ifdef ENABLE_CDI
 #include "cdi_operate_api.h"
 #endif /* ENABLE_CDI */
+#ifdef ENABLE_NRI
+#include "nri_plugin_ops.h"
+#endif
 
 sem_t g_daemon_shutdown_sem;
 sem_t g_daemon_wait_shutdown_sem;
@@ -289,6 +292,11 @@ static void daemon_shutdown()
     EVENT("Network module exit completed");
 #endif
 
+#ifdef ENABLE_NRI
+    nri_adaption_shutdown();
+    EVENT("nri module exit completed");
+#endif
+
     clean_residual_files();
     EVENT("Clean residual files completed");
 
@@ -1834,6 +1842,13 @@ int main(int argc, char **argv)
     }
 #endif
 
+#ifdef ENABLE_NRI
+    if (!nri_adaption_init()) {
+        ERROR("Failed to init nri adaption");
+        goto failure;
+    }
+#endif
+
     clock_gettime(CLOCK_MONOTONIC, &t_end);
     use_time = (double)(t_end.tv_sec - t_start.tv_sec) * (double)1000000000 + (double)(t_end.tv_nsec - t_start.tv_nsec);
     use_time /= 1000000000;
diff --git a/src/daemon/common/nri/nri_convert.cc b/src/daemon/common/nri/nri_convert.cc
index 7cce64ec..30caf1dd 100644
--- a/src/daemon/common/nri/nri_convert.cc
+++ b/src/daemon/common/nri/nri_convert.cc
@@ -20,6 +20,7 @@
 #include "path.h"
 #include "transform.h"
 #include "nri_utils.h"
+#include "cstruct_wrapper.h"
 
 static int64_t DefaultOOMScoreAdj = 0;
 
@@ -142,22 +143,28 @@ static auto NRILinuxResourcesFromCRI(const runtime::v1::LinuxContainerResources
 
 static auto NRILinuxFromCRI(const runtime::v1::LinuxPodSandboxConfig &config, nri_linux_pod_sandbox &linux) -> bool
 {
-    if (!init_nri_linux_resources(&linux.pod_overhead)) {
-        ERROR("Failed to init nri linux overhead resources for pod");
-        return false;
-    }
-    if (!init_nri_linux_resources(&linux.pod_resources)) {
-        ERROR("Failed to init nri linux resources resources for pod");
-        return false;
-    }
-    if (config.has_overhead() && !NRILinuxResourcesFromCRI(config.overhead(), *linux.pod_overhead)) {
-        ERROR("Failed to transform overhead to nri for pod");
-        return false;
+    if (config.has_overhead()) {
+        linux.pod_overhead = init_nri_linux_resources();
+        if (linux.pod_overhead == nullptr) {
+            ERROR("Failed to init nri linux overhead resources for pod");
+            return false;
+        }
+        if (!NRILinuxResourcesFromCRI(config.overhead(), *linux.pod_overhead)) {
+            ERROR("Failed to transform overhead to nri for pod");
+            return false;
+        }
     }
 
-    if (config.has_resources() && !NRILinuxResourcesFromCRI(config.resources(), *linux.pod_resources)) {
-        ERROR("Failed to transform resources to nri for pod");
-        return false;
+    if (config.has_resources()) {
+        linux.pod_resources = init_nri_linux_resources();
+        if (linux.pod_resources == nullptr) {
+            ERROR("Failed to init nri linux resources resources for pod");
+            return false;
+        }
+        if (!NRILinuxResourcesFromCRI(config.resources(), *linux.pod_resources)) {
+            ERROR("Failed to transform resources to nri for pod");
+            return false;
+        }
     }
 
     linux.cgroup_parent = util_strdup_s(config.cgroup_parent().c_str());
@@ -507,13 +514,13 @@ auto LinuxResourcesFromNRI(const nri_linux_resources *src, runtime::v1::LinuxCon
     }
 
     if (src->cpu != nullptr) {
-        if (src->cpu->shares != NULL) {
+        if (src->cpu->shares != nullptr) {
             resources.set_cpu_shares(*src->cpu->shares);
         }
-        if (src->cpu->quota != NULL) {
+        if (src->cpu->quota != nullptr) {
             resources.set_cpu_quota(*src->cpu->quota);
         }
-        if (src->cpu->period != NULL) {
+        if (src->cpu->period != nullptr) {
             resources.set_cpu_period(*src->cpu->period);
         }
 
@@ -535,5 +542,112 @@ auto LinuxResourcesFromNRI(const nri_linux_resources *src, runtime::v1::LinuxCon
         Transform::JsonMapToProtobufMapForString(src->unified, *resources.mutable_unified());
     }
 
+    return true;
+}
+
+auto LinuxResourcesToNRI(const runtime::v1::LinuxContainerResources &src) -> nri_linux_resources *
+{
+    nri_linux_resources *resources = nullptr;
+
+    resources = init_nri_linux_resources();
+    if (resources == nullptr) {
+        ERROR("Failed to init nri linux resources");
+        return nullptr;
+    }
+
+    resources->cpu->shares = (uint64_t *)util_common_calloc_s(sizeof(uint64_t));
+    if (resources->cpu->shares == nullptr) {
+        ERROR("Out of memory");
+        goto error_out;
+    }
+    *(resources->cpu->shares) = src.cpu_shares();
+
+    resources->cpu->quota = (int64_t *)util_common_calloc_s(sizeof(int64_t));
+    if (resources->cpu->quota == nullptr) {
+        ERROR("Out of memory");
+        goto error_out;
+    }
+    *(resources->cpu->quota) = src.cpu_quota();
+
+    resources->cpu->period = (uint64_t *)util_common_calloc_s(sizeof(uint64_t));
+    if (resources->cpu->period == nullptr) {
+        ERROR("Out of memory");
+        goto error_out;
+    }
+    *(resources->cpu->period) = src.cpu_period();
+
+    resources->cpu->cpus = util_strdup_s(src.cpuset_cpus().c_str());
+    resources->cpu->mems = util_strdup_s(src.cpuset_mems().c_str());
+
+    resources->memory->limit = (int64_t *)util_common_calloc_s(sizeof(int64_t));
+    if (resources->memory->limit == nullptr) {
+        ERROR("Out of memory");
+        goto error_out;
+    }
+    *(resources->memory->limit) = src.memory_limit_in_bytes();
+
+    resources->hugepage_limits = (nri_hugepage_limit **)util_smart_calloc_s(sizeof(nri_hugepage_limit *),
+                                                                            src.hugepage_limits_size());
+    if (resources->hugepage_limits == nullptr) {
+        ERROR("Out of memory");
+        goto error_out;
+    }
+
+    for (int i = 0; i < src.hugepage_limits_size(); i++) {
+        resources->hugepage_limits[i] = (nri_hugepage_limit *)util_common_calloc_s(sizeof(nri_hugepage_limit));
+        if (resources->hugepage_limits[i] == nullptr) {
+            ERROR("Out of memory");
+            goto error_out;
+        }
+        resources->hugepage_limits[i]->page_size = util_strdup_s(src.hugepage_limits(i).page_size().c_str());
+        resources->hugepage_limits[i]->limit = src.hugepage_limits(i).limit();
+        resources->hugepage_limits_len++;
+    }
+
+    return resources;
+
+error_out:
+    free_nri_linux_resources(resources);
+    resources = nullptr;
+    return resources;
+}
+
+auto PodSandboxesToNRI(const std::vector<std::shared_ptr<sandbox::Sandbox>> &arrs,
+                       std::vector<nri_pod_sandbox *> &pods) -> bool
+{
+    size_t i = 0;
+    for (i = 0; i < arrs.size(); i++) {
+        nri_pod_sandbox *pod = (nri_pod_sandbox *)util_common_calloc_s(sizeof(nri_pod_sandbox));
+        if (pod == nullptr) {
+            ERROR("Out of memory");
+            return false;
+        }
+        if (!PodSandboxToNRI(arrs[i], *pod)) {
+            ERROR("Failed to transform pod to nri for pod : %s", arrs[i]->GetName().c_str());
+            return false;
+        }
+        pods.push_back(pod);
+    }
+
+    return true;
+}
+
+auto ContainersToNRI(std::vector<std::unique_ptr<runtime::v1::Container>> &containers,
+                     std::vector<nri_container *> &cons) -> bool
+{
+    size_t i = 0;
+    for (i = 0; i < containers.size(); i++) {
+        nri_container *con = (nri_container *)util_common_calloc_s(sizeof(nri_container));
+        if (con == nullptr) {
+            ERROR("Out of memory");
+            return false;
+        }
+        if (!ContainerToNRIByID(containers[i].get()->id(), *con)) {
+            ERROR("Failed to transform container to nri for container : %s", containers[i]->metadata().name().c_str());
+            return false;
+        }
+        cons.push_back(con);
+    }
+
     return true;
 }
\ No newline at end of file
diff --git a/src/daemon/common/nri/nri_convert.h b/src/daemon/common/nri/nri_convert.h
index c04b14e4..a0caf6ce 100644
--- a/src/daemon/common/nri/nri_convert.h
+++ b/src/daemon/common/nri/nri_convert.h
@@ -30,8 +30,11 @@
 auto PodSandboxToNRI(const std::shared_ptr<const sandbox::Sandbox> &sandbox, nri_pod_sandbox &pod) -> bool;
 auto ContainerToNRIByConConfig(const runtime::v1::ContainerConfig &containerConfig, nri_container &con) -> bool;
 auto ContainerToNRIByID(const std::string &id, nri_container &con) -> bool;
-auto PodSandboxesToNRI(const std::vector<std::unique_ptr<sandbox::Sandbox>> &arrs, nri_pod_sandbox **pod,
-                       int pod_len) -> bool;
+auto PodSandboxesToNRI(const std::vector<std::shared_ptr<sandbox::Sandbox>> &arrs,
+                       std::vector<nri_pod_sandbox *> &pods) -> bool;
+auto ContainersToNRI(std::vector<std::unique_ptr<runtime::v1::Container>> &containers,
+                     std::vector<nri_container *> &cons) -> bool;
 
 auto LinuxResourcesFromNRI(const nri_linux_resources *src, runtime::v1::LinuxContainerResources &resources) -> bool;
+auto LinuxResourcesToNRI(const runtime::v1::LinuxContainerResources &src) -> nri_linux_resources *;
 #endif // DAEMON_COMMON_NRI_NRI_CONVERT_H
diff --git a/src/daemon/common/nri/nri_spec.c b/src/daemon/common/nri/nri_spec.c
index 855fe3b3..327d31e1 100644
--- a/src/daemon/common/nri/nri_spec.c
+++ b/src/daemon/common/nri/nri_spec.c
@@ -176,6 +176,7 @@ static int nri_adjust_annotation(const nri_container_adjustment *adjust, oci_run
 
     free_json_map_string_string(oci_spec->annotations);
     oci_spec->annotations = cleard;
+    cleard = NULL;
     ret = 0;
 
 free_out:
@@ -330,7 +331,34 @@ static int nri_adjust_hooks(const nri_container_adjustment *adjust, oci_runtime_
     return ret;
 }
 
-static int nri_adjust_devices(const nri_container_adjustment *adjust, oci_runtime_spec *oci_spec)
+static int host_spec_add_device(host_config *spec, defs_device *device)
+{
+    size_t i;
+
+    if (device == NULL) {
+        return -1;
+    }
+
+    for (i = 0; i < spec->nri_devices_len; i++) {
+        if (strcmp(spec->nri_devices[i]->path, device->path) == 0) {
+            free_defs_device(spec->nri_devices[i]);
+            spec->nri_devices[i] = device;
+            return 0;
+        }
+    }
+
+    if (util_mem_realloc((void **)&spec->nri_devices, (spec->nri_devices_len + 1) * sizeof(defs_device *),
+                         (void *)spec->nri_devices, spec->nri_devices_len * sizeof(defs_device *)) != 0) {
+        ERROR("Out of memory");
+        return -1;
+    }
+    spec->nri_devices[spec->nri_devices_len] = device;
+    spec->nri_devices_len++;
+
+    return 0;
+}
+
+static int nri_adjust_oci_spec_devices(const nri_container_adjustment *adjust, oci_runtime_spec *oci_spec)
 {
     if (adjust->linux == NULL || adjust->linux->devices == NULL || adjust->linux->devices_len == 0) {
         return 0;
@@ -349,6 +377,25 @@ static int nri_adjust_devices(const nri_container_adjustment *adjust, oci_runtim
     return 0;
 }
 
+static int nri_adjust_host_spec_devices(const nri_container_adjustment *adjust, host_config *spec)
+{
+    if (adjust->linux == NULL || adjust->linux->devices == NULL || adjust->linux->devices_len == 0) {
+        return 0;
+    }
+
+    size_t i;
+
+    for (i = 0; i < adjust->linux->devices_len; i++) {
+        nri_linux_device *dev = adjust->linux->devices[i];
+        if (host_spec_add_device(spec, nri_device_to_oci(dev)) != 0) {
+            ERROR("Failed to add device %s", dev->path);
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
 static int nri_adjust_cgroup_path(const nri_container_adjustment *adjust, oci_runtime_spec *oci_spec)
 {
     if (adjust->linux == NULL || adjust->linux->cgroups_path == NULL) {
@@ -500,7 +547,50 @@ static int nri_adjust_mounts(const nri_container_adjustment *adjust, oci_runtime
     return 0;
 }
 
-static int nri_adjust_rlimit(const nri_container_adjustment *adjust, oci_runtime_spec *oci_spec)
+static int host_spec_add_linux_resources_rlimit(host_config *spec, const char *type, uint64_t hard, uint64_t soft)
+{
+    size_t j;
+    bool exists = false;
+    host_config_nri_rlimits_element *rlimit = NULL;
+
+    if (spec == NULL || type == NULL) {
+        ERROR("Invalid arguments");
+        return -1;
+    }
+
+    rlimit = util_common_calloc_s(sizeof(host_config_nri_rlimits_element));
+    if (rlimit == NULL) {
+        ERROR("Out of memory");
+        return -1;
+    }
+    rlimit->type = util_strdup_s(type);
+    rlimit->hard = hard;
+    rlimit->soft = soft;
+
+    for (j = 0; j < spec->nri_rlimits_len; j++) {
+        if (spec->nri_rlimits[j]->type == NULL) {
+            ERROR("rlimit type is empty");
+            free_host_config_nri_rlimits_element(rlimit);
+            return -1;
+        }
+        if (strcmp(spec->nri_rlimits[j]->type, rlimit->type) == 0) {
+            exists = true;
+            break;
+        }
+    }
+    if (exists) {
+        /* override ulimit */
+        free_host_config_nri_rlimits_element(spec->nri_rlimits[j]);
+        spec->nri_rlimits[j] = rlimit;
+    } else {
+        spec->nri_rlimits[spec->nri_rlimits_len] = rlimit;
+        spec->nri_rlimits_len++;
+    }
+
+    return 0;
+}
+
+static int nri_adjust_oci_spec_rlimit(const nri_container_adjustment *adjust, oci_runtime_spec *oci_spec)
 {
     if (adjust->rlimits == NULL || adjust->rlimits_len == 0) {
         return 0;
@@ -522,6 +612,36 @@ static int nri_adjust_rlimit(const nri_container_adjustment *adjust, oci_runtime
     return 0;
 }
 
+static int nri_adjust_host_spec_rlimit(const nri_container_adjustment *adjust, host_config *spec)
+{
+    if (adjust->rlimits == NULL || adjust->rlimits_len == 0) {
+        return 0;
+    }
+
+    if (spec->nri_rlimits == NULL) {
+        spec->nri_rlimits = util_common_calloc_s(sizeof(host_config_nri_rlimits_element *) * adjust->rlimits_len);
+        if (spec->nri_rlimits == NULL) {
+            ERROR("Out of memory");
+            return -1;
+        }
+    }
+
+    size_t i;
+    for (i = 0; i < adjust->rlimits_len; i++) {
+        nri_posix_rlimit *rlimit = adjust->rlimits[i];
+        if (rlimit->type == NULL) {
+            ERROR("Invalid rlimit type");
+            return -1;
+        }
+        if (host_spec_add_linux_resources_rlimit(spec, rlimit->type, rlimit->soft, rlimit->hard) != 0) {
+            ERROR("Failed to add rlimit");
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
 // todo: we do not support it blockio_class
 static int nri_adjust_blockio_class(const nri_container_adjustment *adjust, oci_runtime_spec *oci_spec)
 {
@@ -554,7 +674,7 @@ int nri_adjust_oci_spec(const nri_container_adjustment *adjust, oci_runtime_spec
         return -1;
     }
 
-    if (nri_adjust_devices(adjust, oci_spec) != 0) {
+    if (nri_adjust_oci_spec_devices(adjust, oci_spec) != 0) {
         ERROR("Failed to do nri adjust devices in oci spec");
         return -1;
     }
@@ -580,7 +700,7 @@ int nri_adjust_oci_spec(const nri_container_adjustment *adjust, oci_runtime_spec
         return -1;
     }
 
-    if (nri_adjust_rlimit(adjust, oci_spec) != 0) {
+    if (nri_adjust_oci_spec_rlimit(adjust, oci_spec) != 0) {
         ERROR("Failed to do nri adjust rlimit in oci spec");
         return -1;
     }
@@ -598,5 +718,100 @@ int nri_adjust_oci_spec(const nri_container_adjustment *adjust, oci_runtime_spec
         return -1;
     }
 
+    return 0;
+}
+
+int nri_adjust_host_spec(const nri_container_adjustment *adjust, host_config *host_spec)
+{
+    if (adjust == NULL || host_spec == NULL) {
+        ERROR("Invalid input arguments");
+        return -1;
+    }
+
+    if (nri_adjust_host_spec_devices(adjust, host_spec) != 0) {
+        ERROR("Failed to do nri adjust devices in host config");
+        return -1;
+    }
+
+    if (nri_adjust_host_spec_rlimit(adjust, host_spec) != 0) {
+        ERROR("Failed to do nri adjust rlimit in host config");
+        return -1;
+    }
+
+    return 0;
+}
+
+static defs_device *copy_def_devices(const defs_device *dev)
+{
+    defs_device *tmp_dev = util_common_calloc_s(sizeof(defs_device));
+    if (tmp_dev == NULL) {
+        return NULL;
+    }
+    tmp_dev->type = util_strdup_s(dev->type);
+    tmp_dev->path = util_strdup_s(dev->path);
+    tmp_dev->file_mode = dev->file_mode;
+    tmp_dev->major = dev->major;
+    tmp_dev->minor = dev->minor;
+    tmp_dev->uid = dev->uid;
+    tmp_dev->gid = dev->gid;
+    return tmp_dev;
+}
+
+static int merge_nri_devices(oci_runtime_spec *oci_spec, host_config *host_spec)
+{
+    size_t i;
+
+    if (oci_spec == NULL || host_spec == NULL) {
+        ERROR("Invalid input arguments");
+        return -1;
+    }
+
+    for (i = 0; i < host_spec->nri_devices_len; i++) {
+        if (spec_add_device(oci_spec, copy_def_devices(host_spec->nri_devices[i])) != 0) {
+            ERROR("Failed to add device %s", host_spec->nri_devices[i]->path);
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+static int merge_nri_ulimits(oci_runtime_spec *oci_spec, host_config *host_spec)
+{
+    size_t i;
+
+    if (oci_spec == NULL || host_spec == NULL) {
+        ERROR("Invalid input arguments");
+        return -1;
+    }
+
+    for (i = 0; i < host_spec->nri_rlimits_len; i++) {
+        host_config_nri_rlimits_element *rlimit = host_spec->nri_rlimits[i];
+        if (spec_add_linux_resources_rlimit(oci_spec, rlimit->type, rlimit->hard, rlimit->soft) != 0) {
+            ERROR("Failed to add rlimit %s", rlimit->type);
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+int update_oci_nri(oci_runtime_spec *oci_spec, host_config *host_spec)
+{
+    if (oci_spec == NULL || host_spec == NULL) {
+        ERROR("Invalid input arguments");
+        return -1;
+    }
+
+    if (merge_nri_devices(oci_spec, host_spec) != 0) {
+        ERROR("Failed to merge nri devices");
+        return -1;
+    }
+
+    if (merge_nri_ulimits(oci_spec, host_spec) != 0) {
+        ERROR("Failed to merge nri ulimits");
+        return -1;
+    }
+
     return 0;
 }
\ No newline at end of file
diff --git a/src/daemon/common/nri/nri_spec.h b/src/daemon/common/nri/nri_spec.h
index e7c5035d..1a622284 100644
--- a/src/daemon/common/nri/nri_spec.h
+++ b/src/daemon/common/nri/nri_spec.h
@@ -18,7 +18,13 @@
 
 #include <isula_libutils/oci_runtime_spec.h>
 #include <isula_libutils/nri_container_adjustment.h>
+#include <isula_libutils/host_config.h>
 
 int nri_adjust_oci_spec(const nri_container_adjustment *adjust, oci_runtime_spec *oci_spec);
 
+// the device and ulimit will be updated when starting, so they need to be stored in host-spec
+int nri_adjust_host_spec(const nri_container_adjustment *adjust, host_config *host_spec);
+
+int update_oci_nri(oci_runtime_spec *oci_spec, host_config *host_spec);
+
 #endif // DAEMON_COMMON_NRI_NRI_SPEC_H
\ No newline at end of file
diff --git a/src/daemon/common/nri/nri_utils.c b/src/daemon/common/nri/nri_utils.c
index 51054e32..d2b62117 100644
--- a/src/daemon/common/nri/nri_utils.c
+++ b/src/daemon/common/nri/nri_utils.c
@@ -19,218 +19,235 @@
 
 #include "utils.h"
 
-static bool copy_nri_hugepage_limit(const nri_hugepage_limit* src, nri_hugepage_limit** dest)
+static nri_hugepage_limit*copy_nri_hugepage_limit(const nri_hugepage_limit *src)
 {
-    if (src == NULL || dest == NULL) {
+    nri_hugepage_limit *dest = NULL;
+    if (src == NULL) {
         ERROR("Invalid input arguments");
         return false;
     }
 
-    *dest = (nri_hugepage_limit *)util_common_calloc_s(sizeof(nri_hugepage_limit));
-    if (*dest == NULL) {
+    dest = (nri_hugepage_limit *)util_common_calloc_s(sizeof(nri_hugepage_limit));
+    if (dest == NULL) {
         ERROR("Out of memory");
         return false;
     }
 
-    (*dest)->limit = src->limit;
-    (*dest)->page_size = util_strdup_s(src->page_size);
-    return true;
+    dest->limit = src->limit;
+    dest->page_size = util_strdup_s(src->page_size);
+    return dest;
 }
 
-static bool copy_nri_hook(const nri_hook *src, nri_hook **dest)
+static nri_hook *copy_nri_hook(const nri_hook *src)
 {
-    if (src == NULL || dest == NULL) {
+    nri_hook *dest = NULL;
+    if (src == NULL) {
         ERROR("Invalid input arguments");
         return false;
     }
 
-    *dest = (nri_hook *)util_common_calloc_s(sizeof(nri_hook));
+    dest = (nri_hook *)util_common_calloc_s(sizeof(nri_hook));
     if (dest == NULL) {
         ERROR("Out of memory");
         return false;
     }
-    (*dest)->args = util_copy_array_by_len(src->args, src->args_len);
-    (*dest)->args_len = src->args_len;
-    (*dest)->env = util_copy_array_by_len(src->env, src->env_len);
-    (*dest)->env_len = src->env_len;
-    (*dest)->path = util_strdup_s(src->path);
-    return true;
+    dest->args = util_copy_array_by_len(src->args, src->args_len);
+    dest->args_len = src->args_len;
+    dest->env = util_copy_array_by_len(src->env, src->env_len);
+    dest->env_len = src->env_len;
+    dest->path = util_strdup_s(src->path);
+    return dest;
 }
 
-static bool copy_nri_linux_device_cgroup(const nri_linux_device_cgroup *src, nri_linux_device_cgroup **dest)
+static nri_linux_device_cgroup *copy_nri_linux_device_cgroup(const nri_linux_device_cgroup *src)
 {
-    if (src == NULL || dest == NULL) {
+    nri_linux_device_cgroup *dest = NULL;
+    if (src == NULL) {
         ERROR("Invalid input arguments");
         return false;
     }
 
-    *dest = (nri_linux_device_cgroup *)util_common_calloc_s(sizeof(nri_linux_device_cgroup));
+    dest = (nri_linux_device_cgroup *)util_common_calloc_s(sizeof(nri_linux_device_cgroup));
     if (dest == NULL) {
         ERROR("Out of memory");
         return false;
     }
-    (*dest)->allow = src->allow;
-    (*dest)->type = util_strdup_s(src->type);
-    (*dest)->major = (int64_t *)util_common_calloc_s(sizeof(int64_t));
-    if ((*dest)->major == NULL) {
+    dest->allow = src->allow;
+    dest->type = util_strdup_s(src->type);
+    dest->major = (int64_t *)util_common_calloc_s(sizeof(int64_t));
+    if (dest->major == NULL) {
         ERROR("Out of memory");
-        return false;
+        goto free_out;
     }
-    (*dest)->minor = (int64_t *)util_common_calloc_s(sizeof(int64_t));
-    if ((*dest)->minor == NULL) {
+    dest->minor = (int64_t *)util_common_calloc_s(sizeof(int64_t));
+    if (dest->minor == NULL) {
         ERROR("Out of memory");
-        return false;
+        goto free_out;
     }
-    (*dest)->access = util_strdup_s(src->access);
-    return true;
+    dest->access = util_strdup_s(src->access);
+    return dest;
+free_out:
+    free_nri_linux_device_cgroup(dest);
+    return NULL;
 }
 
-static bool copy_nri_linux_cpu(const nri_linux_cpu *src, nri_linux_cpu **dest)
+static nri_linux_cpu *copy_nri_linux_cpu(const nri_linux_cpu *src)
 {
-    if (src == NULL || dest == NULL) {
+    nri_linux_cpu *dest = NULL;
+    if (src == NULL) {
         ERROR("Invalid input arguments");
         return false;
     }
 
-    (*dest) = (nri_linux_cpu *)util_common_calloc_s(sizeof(nri_linux_cpu));
-    if ((*dest) == NULL) {
+    dest = (nri_linux_cpu *)util_common_calloc_s(sizeof(nri_linux_cpu));
+    if (dest == NULL) {
         ERROR("Out of memory");
         return false;
     }
-    (*dest)->cpus = util_strdup_s(src->cpus);
-    (*dest)->mems = util_strdup_s(src->mems);
+    dest->cpus = util_strdup_s(src->cpus);
+    dest->mems = util_strdup_s(src->mems);
     if (src->period != NULL) {
-        (*dest)->period = (uint64_t *)util_common_calloc_s(sizeof(uint64_t));
-        if ((*dest)->period == NULL) {
+        dest->period = (uint64_t *)util_common_calloc_s(sizeof(uint64_t));
+        if (dest->period == NULL) {
             ERROR("Out of memory");
-            return false;
+            goto free_out;
         }
-        *(*dest)->period = *src->period;
+        *dest->period = *src->period;
     }
 
     if (src->quota != NULL) {
-        (*dest)->quota = (int64_t *)util_common_calloc_s(sizeof(int64_t));
-        if ((*dest)->quota == NULL) {
+        dest->quota = (int64_t *)util_common_calloc_s(sizeof(int64_t));
+        if (dest->quota == NULL) {
             ERROR("Out of memory");
-            return false;
+            goto free_out;
         }
-        *(*dest)->quota = *src->quota;
+        *dest->quota = *src->quota;
     }
 
     if (src->realtime_period != NULL) {
-        (*dest)->realtime_period = (uint64_t *)util_common_calloc_s(sizeof(uint64_t));
-        if ((*dest)->realtime_period == NULL) {
+        dest->realtime_period = (uint64_t *)util_common_calloc_s(sizeof(uint64_t));
+        if (dest->realtime_period == NULL) {
             ERROR("Out of memory");
-            return false;
+            goto free_out;
         }
-        *(*dest)->realtime_period = *src->realtime_period;
+        *dest->realtime_period = *src->realtime_period;
     }
 
     if (src->realtime_runtime != NULL) {
-        (*dest)->realtime_runtime = (int64_t *)util_common_calloc_s(sizeof(int64_t));
-        if ((*dest)->realtime_runtime == NULL) {
+        dest->realtime_runtime = (int64_t *)util_common_calloc_s(sizeof(int64_t));
+        if (dest->realtime_runtime == NULL) {
             ERROR("Out of memory");
-            return false;
+            goto free_out;
         }
-        *(*dest)->realtime_runtime = *src->realtime_runtime;
+        *dest->realtime_runtime = *src->realtime_runtime;
     }
 
     if (src->shares != NULL) {
-        (*dest)->shares = (uint64_t *)util_common_calloc_s(sizeof(uint64_t));
-        if ((*dest)->shares == NULL) {
+        dest->shares = (uint64_t *)util_common_calloc_s(sizeof(uint64_t));
+        if (dest->shares == NULL) {
             ERROR("Out of memory");
-            return false;
+            goto free_out;
         }
-        *(*dest)->shares = *src->shares;
+        *dest->shares = *src->shares;
     }
 
-    return true;
+    return dest;
+
+free_out:
+    free_nri_linux_cpu(dest);
+    return NULL;
 }
 
-static bool copy_nri_linux_memory(const nri_linux_memory *src, nri_linux_memory **dest)
+static nri_linux_memory *copy_nri_linux_memory(const nri_linux_memory *src)
 {
-    if (src == NULL || dest == NULL) {
+    nri_linux_memory *dest = NULL;
+    if (src == NULL) {
         ERROR("Invalid input arguments");
         return false;
     }
-    *dest = (nri_linux_memory *)util_common_calloc_s(sizeof(nri_linux_memory));
+    
+    dest = (nri_linux_memory *)util_common_calloc_s(sizeof(nri_linux_memory));
     if (dest == NULL) {
         ERROR("Out of memory");
         return false;
     }
     if (src->limit != NULL) {
-        (*dest)->limit = (int64_t *)util_common_calloc_s(sizeof(int64_t));
-        if ((*dest)->limit == NULL) {
+        dest->limit = (int64_t *)util_common_calloc_s(sizeof(int64_t));
+        if (dest->limit == NULL) {
             ERROR("Out of memory");
-            return false;
+            goto free_out;
         }
-        *(*dest)->limit = *src->limit;
+        *dest->limit = *src->limit;
     }
 
     if (src->reservation != NULL) {
-        (*dest)->reservation = (int64_t *)util_common_calloc_s(sizeof(int64_t));
-        if ((*dest)->reservation == NULL) {
+        dest->reservation = (int64_t *)util_common_calloc_s(sizeof(int64_t));
+        if (dest->reservation == NULL) {
             ERROR("Out of memory");
-            return false;
+            goto free_out;
         }
-        *(*dest)->reservation = *src->reservation;
+        *dest->reservation = *src->reservation;
     }
 
     if (src->swap != NULL) {
-        (*dest)->swap = (int64_t *)util_common_calloc_s(sizeof(int64_t));
-        if ((*dest)->swap == NULL) {
+        dest->swap = (int64_t *)util_common_calloc_s(sizeof(int64_t));
+        if (dest->swap == NULL) {
             ERROR("Out of memory");
-            return false;
+            goto free_out;
         }
-        *(*dest)->swap = *src->swap;
+        *dest->swap = *src->swap;
     }
 
     if (src->kernel != NULL) {
-        (*dest)->kernel = (int64_t *)util_common_calloc_s(sizeof(int64_t));
-        if ((*dest)->kernel == NULL) {
+        dest->kernel = (int64_t *)util_common_calloc_s(sizeof(int64_t));
+        if (dest->kernel == NULL) {
             ERROR("Out of memory");
-            return false;
+            goto free_out;
         }
-        *(*dest)->kernel = *src->kernel;
+        *dest->kernel = *src->kernel;
     }
 
 
     if (src->kernel_tcp != NULL) {
-        (*dest)->kernel_tcp = (int64_t *)util_common_calloc_s(sizeof(int64_t));
-        if ((*dest)->kernel_tcp == NULL) {
+        dest->kernel_tcp = (int64_t *)util_common_calloc_s(sizeof(int64_t));
+        if (dest->kernel_tcp == NULL) {
             ERROR("Out of memory");
-            return false;
+            goto free_out;
         }
-        *(*dest)->kernel_tcp = *src->kernel_tcp;
+        *dest->kernel_tcp = *src->kernel_tcp;
     }
 
     if (src->swappiness != NULL) {
-        (*dest)->swappiness = (uint64_t *)util_common_calloc_s(sizeof(uint64_t));
-        if ((*dest)->swappiness == NULL) {
+        dest->swappiness = (uint64_t *)util_common_calloc_s(sizeof(uint64_t));
+        if (dest->swappiness == NULL) {
             ERROR("Out of memory");
-            return false;
+            goto free_out;
         }
-        *(*dest)->swappiness = *src->swappiness;
+        *dest->swappiness = *src->swappiness;
     }
 
     if (src->disable_oom_killer != NULL) {
-        (*dest)->disable_oom_killer = (uint8_t *)util_common_calloc_s(sizeof(uint8_t));
-        if ((*dest)->disable_oom_killer == NULL) {
+        dest->disable_oom_killer = (uint8_t *)util_common_calloc_s(sizeof(uint8_t));
+        if (dest->disable_oom_killer == NULL) {
             ERROR("Out of memory");
-            return false;
+            goto free_out;
         }
-        *(*dest)->disable_oom_killer = *src->disable_oom_killer;
+        *dest->disable_oom_killer = *src->disable_oom_killer;
     }
 
     if (src->use_hierarchy != NULL) {
-        (*dest)->use_hierarchy = (uint8_t *)util_common_calloc_s(sizeof(uint8_t));
-        if ((*dest)->use_hierarchy == NULL) {
+        dest->use_hierarchy = (uint8_t *)util_common_calloc_s(sizeof(uint8_t));
+        if (dest->use_hierarchy == NULL) {
             ERROR("Out of memory");
-            return false;
+            goto free_out;
         }
-        *(*dest)->use_hierarchy = *src->use_hierarchy;
+        *dest->use_hierarchy = *src->use_hierarchy;
     }
-    return true;
+    return dest;
+
+free_out:
+    free_nri_linux_memory(dest);
+    return NULL;
 }
 
 bool is_marked_for_removal(const char* key, char **out)
@@ -241,7 +258,7 @@ bool is_marked_for_removal(const char* key, char **out)
     }
 
     if (!util_has_prefix(key, "-")) {
-        *out = (char*)key;
+        *out = util_strdup_s(key);
         return false;
     }
 
@@ -254,94 +271,153 @@ bool is_marked_for_removal(const char* key, char **out)
     return true;
 }
 
-bool copy_nri_mount(const nri_mount *src, nri_mount **dest)
+nri_mount *copy_nri_mount(const nri_mount *src)
 {
-    if (src == NULL || dest == NULL) {
+    nri_mount *dest = NULL;
+    if (src == NULL) {
         ERROR("Invalid input arguments");
         return false;
     }
-    *dest = (nri_mount *)util_common_calloc_s(sizeof(nri_mount));
+
+    dest = (nri_mount *)util_common_calloc_s(sizeof(nri_mount));
     if (dest == NULL) {
         ERROR("Out of memory");
         return false;
     }
-    (*dest)->destination = util_strdup_s(src->destination);
-    (*dest)->options = util_copy_array_by_len(src->options, src->options_len);
-    (*dest)->options_len = src->options_len;
-    (*dest)->source = util_strdup_s(src->source);
-    (*dest)->type = util_strdup_s(src->type);
-    return true;
+    dest->destination = util_strdup_s(src->destination);
+    dest->options = util_copy_array_by_len(src->options, src->options_len);
+    dest->options_len = src->options_len;
+    dest->source = util_strdup_s(src->source);
+    dest->type = util_strdup_s(src->type);
+    return dest;
 }
 
-bool copy_nri_key_value(const nri_key_value *src, nri_key_value **dest)
+nri_linux_device *copy_nri_device(const nri_linux_device *src)
 {
-    if (src == NULL || dest == NULL) {
+    nri_linux_device *dest = NULL;
+
+    if (src == NULL) {
         ERROR("Invalid input arguments");
         return false;
     }
-    *dest = (nri_key_value *)util_common_calloc_s(sizeof(nri_key_value));
+    
+    dest = (nri_linux_device *)util_common_calloc_s(sizeof(nri_linux_device));
     if (dest == NULL) {
         ERROR("Out of memory");
         return false;
     }
-    (*dest)->key = util_strdup_s(src->key);
-    (*dest)->value = util_strdup_s(src->value);
-    return true;
+    if (src->file_mode != NULL) {
+        dest->file_mode = (uint32_t *)util_common_calloc_s(sizeof(uint32_t));
+        if (dest->file_mode == NULL) {
+            ERROR("Out of memory");
+            goto free_out;
+        }
+        *dest->file_mode = *src->file_mode;
+    }
+
+    if (src->uid != NULL) {
+        dest->uid = (uint32_t *)util_common_calloc_s(sizeof(uint32_t));
+        if (dest->uid == NULL) {
+            ERROR("Out of memory");
+            goto free_out;
+        }
+        *dest->uid = *src->uid;
+    }
+
+    if (src->gid != NULL) {
+        dest->gid = (uint32_t *)util_common_calloc_s(sizeof(uint32_t));
+        if (dest->gid == NULL) {
+            ERROR("Out of memory");
+            goto free_out;
+        }
+        *dest->gid = *src->gid;
+    }
+
+    dest->major = src->major;
+    dest->minor = src->minor;
+    dest->path = util_strdup_s(src->path);
+    dest->type = util_strdup_s(src->type);
+
+    return dest;
+free_out:
+    free_nri_linux_device(dest);
+    return NULL;
 }
 
-bool copy_nri_posix_rlimit(const nri_posix_rlimit *src, nri_posix_rlimit **dest)
+nri_key_value *copy_nri_key_value(const nri_key_value *src)
 {
-    if (src == NULL || dest == NULL) {
+    nri_key_value *dest = NULL;
+    if (src == NULL) {
         ERROR("Invalid input arguments");
         return false;
     }
-    *dest = (nri_posix_rlimit *)util_common_calloc_s(sizeof(nri_posix_rlimit));
+    dest = (nri_key_value *)util_common_calloc_s(sizeof(nri_key_value));
     if (dest == NULL) {
         ERROR("Out of memory");
         return false;
     }
-    (*dest)->hard = src->hard;
-    (*dest)->soft = src->soft;
-    (*dest)->type = util_strdup_s(src->type);
-    return true;
+    dest->key = util_strdup_s(src->key);
+    dest->value = util_strdup_s(src->value);
+    return dest;
 }
 
-bool copy_nri_linux_resources(const nri_linux_resources *src, nri_linux_resources **dest)
+nri_posix_rlimit *copy_nri_posix_rlimit(const nri_posix_rlimit *src)
 {
-    if (src == NULL || dest == NULL) {
+    nri_posix_rlimit *dest = NULL;
+    if (src == NULL) {
         ERROR("Invalid input arguments");
         return false;
     }
-
-    *dest = (nri_linux_resources *)util_common_calloc_s(sizeof(nri_linux_resources));
-    if (*dest == NULL) {
+    dest = (nri_posix_rlimit *)util_common_calloc_s(sizeof(nri_posix_rlimit));
+    if (dest == NULL) {
         ERROR("Out of memory");
         return false;
     }
+    dest->hard = src->hard;
+    dest->soft = src->soft;
+    dest->type = util_strdup_s(src->type);
+    return dest;
+}
 
-    if (!init_nri_linux_resources(dest)) {
-        ERROR("Failed to init dest nri linux resources");
-        goto free_out;
+nri_linux_resources *copy_nri_linux_resources(const nri_linux_resources *src)
+{
+    nri_linux_resources *dest = NULL;
+    if (src == NULL) {
+        ERROR("Invalid input arguments");
+        return false;
     }
 
-    if (!copy_nri_linux_cpu(src->cpu, &(*dest)->cpu)) {
-        ERROR("Failed to copy nri_linux_cpu");
-        goto free_out;
+    dest = (nri_linux_resources *)util_common_calloc_s(sizeof(nri_linux_resources));
+    if (dest == NULL) {
+        ERROR("Out of memory");
+        return false;
     }
 
-    if (!copy_nri_linux_memory(src->memory, &(*dest)->memory)) {
-        ERROR("Failed to copy nri_linux_memory");
-        goto free_out;
+    if (src->cpu != NULL) {
+        dest->cpu = copy_nri_linux_cpu(src->cpu);
+        if (dest->cpu == NULL) {
+            ERROR("Failed to copy nri_linux_cpu");
+            goto free_out;
+        }
     }
 
-    (*dest)->blockio_class = util_strdup_s(src->blockio_class);
-    (*dest)->rdt_class = util_strdup_s(src->rdt_class);
+    if (src->memory != NULL) {
+        dest->memory = copy_nri_linux_memory(src->memory);
+        if (dest->memory == NULL) {
+            ERROR("Failed to copy nri_linux_memory");
+            goto free_out;
+        }
+    }
+
+    dest->blockio_class = util_strdup_s(src->blockio_class);
+    dest->rdt_class = util_strdup_s(src->rdt_class);
 
     if (src->hugepage_limits_len > 0) {
-        (*dest)->hugepage_limits = (nri_hugepage_limit**)util_smart_calloc_s(sizeof(nri_hugepage_limit*),
+        dest->hugepage_limits = (nri_hugepage_limit**)util_smart_calloc_s(sizeof(nri_hugepage_limit*),
                                                                              src->hugepage_limits_len);
-        for (size_t i = 0; i < src->hugepage_limits_len; ++i) {
-            if (!copy_nri_hugepage_limit(src->hugepage_limits[i], &((*dest)->hugepage_limits[i]))) {
+        for (size_t i = 0; i < src->hugepage_limits_len; i++) {
+            dest->hugepage_limits[i] = copy_nri_hugepage_limit(src->hugepage_limits[i]);
+            if (dest->hugepage_limits[i] == NULL) {
                 ERROR("Failed to copy nri_hugepage_limit");
                 goto free_out;
             }
@@ -349,25 +425,26 @@ bool copy_nri_linux_resources(const nri_linux_resources *src, nri_linux_resource
     }
 
     if (src->devices_len > 0) {
-        (*dest)->devices = (nri_linux_device_cgroup**)util_smart_calloc_s(sizeof(nri_linux_device_cgroup*), src->devices_len);
-        for (size_t i = 0; i < src->devices_len; ++i) {
-            if (!copy_nri_linux_device_cgroup(src->devices[i], &((*dest)->devices[i]))) {
+        dest->devices = (nri_linux_device_cgroup**)util_smart_calloc_s(sizeof(nri_linux_device_cgroup*), src->devices_len);
+        for (size_t i = 0; i < src->devices_len; i++) {
+            dest->devices[i] = copy_nri_linux_device_cgroup(src->devices[i]);
+            if (dest->devices[i] == NULL) {
                 ERROR("Failed to copy nri_linux_device_cgroup");
                 goto free_out;
             }
         }
     }
 
-    if (dup_json_map_string_string(src->unified, (*dest)->unified)) {
+    if (dup_json_map_string_string(src->unified, dest->unified)) {
         ERROR("Failed to copy json_map_string_string");
         goto free_out;
     }
 
-    return true;
+    return dest;
 
 free_out:
-    free_nri_linux_resources(*dest);
-    return false;
+    free_nri_linux_resources(dest);
+    return NULL;
 }
 
 bool merge_nri_hooks(nri_hook **targetHooks, size_t targetSize, const nri_hook **sourceHooks,
@@ -381,140 +458,67 @@ bool merge_nri_hooks(nri_hook **targetHooks, size_t targetSize, const nri_hook *
         return false;
     }
 
-    if (util_mem_realloc((void**)&targetHooks, newSize, (void**)&targetHooks, oldSize) != 0) {
+    if (util_mem_realloc((void**)&targetHooks, newSize, targetHooks, oldSize) != 0) {
         ERROR("Failed to realloc and assign hook array");
         return false;
     }
 
     for (size_t i = 0; i < sourceLen; i++) {
-        if (!copy_nri_hook(sourceHooks[i], &targetHooks[targetSize++])) {
+        targetHooks[targetSize] = copy_nri_hook(sourceHooks[i]);
+        if (targetHooks[targetSize] == NULL) {
             ERROR("Failed to copy hook");
             return false;
         }
+        targetSize++;
     }
 
     return true;
 }
 
-bool init_nri_container_adjust(nri_container_adjustment **adjust)
+nri_container_update *init_nri_container_update(const char *id, const uint8_t ignore_failure)
 {
-    if (adjust == NULL) {
+    nri_container_update *update = NULL;
+    if (id == NULL) {
         ERROR("Invalid input arguments");
         return false;
     }
 
-    *adjust = (nri_container_adjustment *)util_common_calloc_s(sizeof(nri_container_adjustment));
-    if (*adjust == NULL) {
+    update = (nri_container_update *)util_common_calloc_s(sizeof(nri_container_update));
+    if (update == NULL) {
         ERROR("Out of memory");
         return false;
     }
 
-    (*adjust)->annotations = (json_map_string_string *)util_common_calloc_s(sizeof(json_map_string_string));
-    if ((*adjust)->annotations == NULL) {
-        goto free_out;
-    }
-
-    (*adjust)->env = (nri_key_value **)util_common_calloc_s(sizeof(nri_key_value *));
-    if ((*adjust)->env == NULL) {
-        goto free_out;
-    }
-    (*adjust)->env_len = 0;
-
-    (*adjust)->hooks = (nri_hooks *)util_common_calloc_s(sizeof(nri_hooks));
-    if ((*adjust)->hooks == NULL) {
-        goto free_out;
-    }
-
-    (*adjust)->linux = (nri_linux_container_adjustment *)util_common_calloc_s(sizeof(nri_linux_container_adjustment));
-    if ((*adjust)->linux == NULL) {
-        goto free_out;
-    }
-
-    (*adjust)->linux->resources = (nri_linux_resources *)util_common_calloc_s(sizeof(nri_linux_resources));
-    if ((*adjust)->linux->resources == NULL) {
-        ERROR("Out of memory");
-        return false;
-    }
-
-    (*adjust)->mounts = (nri_mount **)util_common_calloc_s(sizeof(nri_mount *));
-    if ((*adjust)->mounts == NULL) {
-        goto free_out;
-    }
-    (*adjust)->mounts_len = 0;
-
-    (*adjust)->rlimits = (nri_posix_rlimit **)util_common_calloc_s(sizeof(nri_posix_rlimit *));
-    if ((*adjust)->rlimits == NULL) {
-        goto free_out;
-    }
-    (*adjust)->rlimits_len = 0;
+    update->container_id = util_strdup_s(id);
 
-    return true;
-
-free_out:
-    ERROR("Out of memory");
-    free_nri_container_adjustment(*adjust);
-    return false;
+    update->ignore_failure = ignore_failure;
+    return update;
 }
 
-bool init_nri_container_update(nri_container_update **update, const char *id, uint8_t ignore_failure)
+nri_linux_resources *init_nri_linux_resources()
 {
-    if (update == NULL || id == NULL) {
-        ERROR("Invalid input arguments");
-        return false;
-    }
-
-    *update = (nri_container_update *)util_common_calloc_s(sizeof(nri_container_update));
-    if (*update == NULL) {
-        ERROR("Out of memory");
-        return false;
-    }
-
-    (*update)->container_id = util_strdup_s(id);
-    (*update)->linux = (nri_linux_container_update *)util_common_calloc_s(sizeof(nri_linux_container_update));
-    if ((*update)->linux == NULL) {
-        goto free_out;
-    }
+    nri_linux_resources *resources = NULL;
 
-    (*update)->ignore_failure = ignore_failure;
-    return true;
-
-free_out:
-    ERROR("Out of memory");
-    free_nri_container_update(*update);
-    return false;
-}
-
-bool init_nri_linux_resources(nri_linux_resources **resources)
-{
+    resources = (nri_linux_resources *)util_common_calloc_s(sizeof(nri_linux_resources));
     if (resources == NULL) {
-        ERROR("Invalid input arguments");
-        return false;
-    }
-
-    *resources = (nri_linux_resources *)util_common_calloc_s(sizeof(nri_linux_resources));
-    if (*resources == NULL) {
         ERROR("Out of memory");
         return false;
     }
 
-    (*resources)->cpu = (nri_linux_cpu *)util_common_calloc_s(sizeof(nri_linux_cpu));
-    if ((*resources)->cpu == NULL) {
+    resources->cpu = (nri_linux_cpu *)util_common_calloc_s(sizeof(nri_linux_cpu));
+    if (resources->cpu == NULL) {
         goto free_out;
     }
 
-    (*resources)->memory = (nri_linux_memory *)util_common_calloc_s(sizeof(nri_linux_memory));
-    if ((*resources)->memory == NULL) {
+    resources->memory = (nri_linux_memory *)util_common_calloc_s(sizeof(nri_linux_memory));
+    if (resources->memory == NULL) {
         goto free_out;
     }
 
-    (*resources)->unified = (json_map_string_string *)util_common_calloc_s(sizeof(json_map_string_string));
-    if ((*resources)->unified == NULL) {
-        goto free_out;
-    }
-    return true;
+    return resources;
 
 free_out:
     ERROR("Out of memory");
-    free_nri_linux_resources(*resources);
-    return false;
+    free_nri_linux_resources(resources);
+    return NULL;
 }
\ No newline at end of file
diff --git a/src/daemon/common/nri/nri_utils.h b/src/daemon/common/nri/nri_utils.h
index 7bf54a71..171055df 100644
--- a/src/daemon/common/nri/nri_utils.h
+++ b/src/daemon/common/nri/nri_utils.h
@@ -49,19 +49,19 @@ typedef enum {
     LAST = 12,
 } NRI_Event;
 
-bool copy_nri_mount(const nri_mount *src, nri_mount **dest);
-bool copy_nri_key_value(const nri_key_value *src, nri_key_value **dest);
-bool copy_nri_posix_rlimit(const nri_posix_rlimit *src, nri_posix_rlimit **dest);
-bool copy_nri_linux_resources(const nri_linux_resources *src, nri_linux_resources **dest);
+nri_mount *copy_nri_mount(const nri_mount *src);
+nri_posix_rlimit *copy_nri_posix_rlimit(const nri_posix_rlimit *src);
+nri_linux_resources *copy_nri_linux_resources(const nri_linux_resources *src);
+nri_key_value *copy_nri_key_value(const nri_key_value *src);
+nri_linux_device *copy_nri_device(const nri_linux_device *src);
 
 bool is_marked_for_removal(const char* key, char **out);
 
 bool merge_nri_hooks(nri_hook **targetHooks, size_t targetSize, const nri_hook **sourceHooks,
                      size_t sourceLen);
 
-bool init_nri_container_adjust(nri_container_adjustment **adjust);
-bool init_nri_container_update(nri_container_update **update, const char *id, uint8_t ignore_failure);
-bool init_nri_linux_resources(nri_linux_resources **resources);
+nri_container_update *init_nri_container_update(const char *id, const uint8_t ignore_failure);
+nri_linux_resources *init_nri_linux_resources(void);
 
 #ifdef __cplusplus
 }
diff --git a/src/daemon/config/isulad_config.c b/src/daemon/config/isulad_config.c
index 9ba1c8a0..020c9f32 100644
--- a/src/daemon/config/isulad_config.c
+++ b/src/daemon/config/isulad_config.c
@@ -1938,7 +1938,7 @@ int merge_json_confs_into_global(struct service_arguments *args)
     override_string_value(&args->json_confs->plugin_path, &tmp_json_confs->plugin_path);
     args->json_confs->plugin_registration_timeout = tmp_json_confs->plugin_registration_timeout;
     args->json_confs->plugin_requst_timeout = tmp_json_confs->plugin_requst_timeout;
-    override_string_value(&args->json_confs->nri_socket_path, &tmp_json_confs->nri_socket_path);
+    // Setting socket plugin path is not supported now
 #endif
     args->json_confs->enable_pod_events = tmp_json_confs->enable_pod_events;
 #endif
diff --git a/src/daemon/entry/cri/v1/v1_cri_container_manager_service.cc b/src/daemon/entry/cri/v1/v1_cri_container_manager_service.cc
index 1cee68ec..d3fdd76a 100644
--- a/src/daemon/entry/cri/v1/v1_cri_container_manager_service.cc
+++ b/src/daemon/entry/cri/v1/v1_cri_container_manager_service.cc
@@ -27,6 +27,11 @@
 #include "stream_server.h"
 #include "sandbox_manager.h"
 
+#ifdef ENABLE_NRI
+#include "nri_adaption.h"
+#include "nri_helpers.h"
+#endif
+
 namespace CRIV1 {
 auto ContainerManagerService::GetContainerOrSandboxRuntime(const std::string &realID, Errors &error) -> std::string
 {
@@ -505,11 +510,24 @@ std::string ContainerManagerService::CreateContainer(const std::string &podSandb
         return response_id;
     }
 
+#ifdef ENABLE_NRI
+    Errors nriErr;
+    nri_container_adjustment *adjust = NULL;
+    if (!NRIAdaptation::GetInstance()->CreateContainer(sandbox, response_id, containerConfig, &adjust, nriErr)) {
+        ERROR("Failed to get NRI adjustment for container: %s", nriErr.GetCMessage());
+        NRIAdaptation::GetInstance()->UndoCreateContainer(sandbox, response_id, nriErr);
+        return response_id;
+    }
+#endif
+
     request = GenerateCreateContainerRequest(*sandbox, containerConfig, podSandboxConfig, error);
     if (error.NotEmpty()) {
         error.SetError("Failed to generate create container request");
         goto cleanup;
     }
+#ifdef ENABLE_NRI
+    request->adjust = adjust;
+#endif
 
     if (m_cb->container.create(request, &response) != 0) {
         if (response != nullptr && (response->errmsg != nullptr)) {
@@ -522,6 +540,12 @@ std::string ContainerManagerService::CreateContainer(const std::string &podSandb
 
     response_id = response->id;
 
+#ifdef ENABLE_NRI
+    if (!NRIAdaptation::GetInstance()->PostCreateContainer(response_id, nriErr)) {
+        ERROR("NRI post-create notification failed: %s", nriErr.GetCMessage());
+    }
+#endif
+
 cleanup:
     free_container_create_request(request);
     free_container_create_response(response);
@@ -530,6 +554,9 @@ cleanup:
 
 void ContainerManagerService::StartContainer(const std::string &containerID, Errors &error)
 {
+#ifdef ENABLE_NRI
+    Errors nriErr;
+#endif
     if (containerID.empty()) {
         error.SetError("Invalid empty container id.");
         return;
@@ -563,6 +590,14 @@ void ContainerManagerService::StartContainer(const std::string &containerID, Err
         goto cleanup;
     }
 
+#ifdef ENABLE_NRI
+    if (!NRIAdaptation::GetInstance()->StartContainer(containerID, nriErr)) {
+        ERROR("NRI container start failed: %s", nriErr.GetCMessage());
+        NRIAdaptation::GetInstance()->StopContainer(containerID, nriErr);
+        goto cleanup;
+    }
+#endif
+
     if (ret != 0) {
         if (response != nullptr && response->errmsg != nullptr) {
             error.SetError(response->errmsg);
@@ -571,6 +606,11 @@ void ContainerManagerService::StartContainer(const std::string &containerID, Err
         }
         goto cleanup;
     }
+#ifdef ENABLE_NRI
+    if (!NRIAdaptation::GetInstance()->PostStartContainer(containerID, nriErr)) {
+        ERROR("NRI PostStartContainer notification failed: %s", nriErr.GetCMessage());
+    }
+#endif
 cleanup:
     free_container_start_request(request);
     free_container_start_response(response);
@@ -578,11 +618,25 @@ cleanup:
 
 void ContainerManagerService::StopContainer(const std::string &containerID, int64_t timeout, Errors &error)
 {
+#ifdef ENABLE_NRI
+    Errors nriErr;
+#endif
     CRIHelpers::StopContainer(m_cb, containerID, timeout, error);
+#ifdef ENABLE_NRI
+    if (!NRIAdaptation::GetInstance()->StopContainer(containerID, nriErr)) {
+        ERROR("NRI StopContainer notification failed: %s", nriErr.GetCMessage());
+    }
+#endif
 }
 
 void ContainerManagerService::RemoveContainer(const std::string &containerID, Errors &error)
 {
+#ifdef ENABLE_NRI
+    Errors nriErr;
+    if (!NRIAdaptation::GetInstance()->RemoveContainer(containerID, nriErr)) {
+        ERROR("NRI RemoveContainer notification failed: %s", nriErr.GetCMessage());
+    }
+#endif
     CRIHelpers::RemoveContainer(m_cb, containerID, error);
     if (error.NotEmpty()) {
         WARN("Failed to remove container %s", containerID.c_str());
@@ -1048,6 +1102,18 @@ void ContainerManagerService::UpdateContainerResources(const std::string &contai
     struct parser_context ctx {
         OPT_GEN_SIMPLIFY, 0
     };
+
+    runtime::v1::LinuxContainerResources updateRes = resources;
+#ifdef ENABLE_NRI
+    Errors nriErr;
+    runtime::v1::LinuxContainerResources adjust;
+    if (!NRIAdaptation::GetInstance()->UpdateContainer(containerID, resources, adjust, nriErr)) {
+        ERROR("NRI UpdateContainer notification failed: %s", nriErr.GetCMessage());
+        goto cleanup;
+    }
+    updateRes = adjust;
+#endif
+
     request = (container_update_request *)util_common_calloc_s(sizeof(container_update_request));
     if (request == nullptr) {
         error.SetError("Out of memory");
@@ -1061,17 +1127,17 @@ void ContainerManagerService::UpdateContainerResources(const std::string &contai
         goto cleanup;
     }
 
-    hostconfig->cpu_period = resources.cpu_period();
-    hostconfig->cpu_quota = resources.cpu_quota();
-    hostconfig->cpu_shares = resources.cpu_shares();
+    hostconfig->cpu_period = updateRes.cpu_period();
+    hostconfig->cpu_quota = updateRes.cpu_quota();
+    hostconfig->cpu_shares = updateRes.cpu_shares();
 
-    if (!resources.unified().empty()) {
+    if (!updateRes.unified().empty()) {
         hostconfig->unified = (json_map_string_string *)util_common_calloc_s(sizeof(json_map_string_string));
         if (hostconfig->unified == nullptr) {
             error.SetError("Out of memory");
             goto cleanup;
         }
-        for (auto &iter : resources.unified()) {
+        for (auto &iter : updateRes.unified()) {
             if (append_json_map_string_string(hostconfig->unified, iter.first.c_str(), iter.second.c_str()) != 0) {
                 error.SetError("Failed to append string");
                 goto cleanup;
@@ -1079,30 +1145,30 @@ void ContainerManagerService::UpdateContainerResources(const std::string &contai
         }
     }
 
-    hostconfig->memory = resources.memory_limit_in_bytes();
-    hostconfig->memory_swap = resources.memory_swap_limit_in_bytes();
-    if (!resources.cpuset_cpus().empty()) {
-        hostconfig->cpuset_cpus = util_strdup_s(resources.cpuset_cpus().c_str());
+    hostconfig->memory = updateRes.memory_limit_in_bytes();
+    hostconfig->memory_swap = updateRes.memory_swap_limit_in_bytes();
+    if (!updateRes.cpuset_cpus().empty()) {
+        hostconfig->cpuset_cpus = util_strdup_s(updateRes.cpuset_cpus().c_str());
     }
-    if (!resources.cpuset_mems().empty()) {
-        hostconfig->cpuset_mems = util_strdup_s(resources.cpuset_mems().c_str());
+    if (!updateRes.cpuset_mems().empty()) {
+        hostconfig->cpuset_mems = util_strdup_s(updateRes.cpuset_mems().c_str());
     }
-    if (resources.hugepage_limits_size() != 0) {
+    if (updateRes.hugepage_limits_size() != 0) {
         hostconfig->hugetlbs = (host_config_hugetlbs_element **)util_smart_calloc_s(
-                                   sizeof(host_config_hugetlbs_element *), resources.hugepage_limits_size());
+                                   sizeof(host_config_hugetlbs_element *), updateRes.hugepage_limits_size());
         if (hostconfig->hugetlbs == nullptr) {
             error.SetError("Out of memory");
             goto cleanup;
         }
-        for (int i = 0; i < resources.hugepage_limits_size(); i++) {
+        for (int i = 0; i < updateRes.hugepage_limits_size(); i++) {
             hostconfig->hugetlbs[i] =
                 (host_config_hugetlbs_element *)util_common_calloc_s(sizeof(host_config_hugetlbs_element));
             if (hostconfig->hugetlbs[i] == nullptr) {
                 error.SetError("Out of memory");
                 goto cleanup;
             }
-            hostconfig->hugetlbs[i]->page_size = util_strdup_s(resources.hugepage_limits(i).page_size().c_str());
-            hostconfig->hugetlbs[i]->limit = resources.hugepage_limits(i).limit();
+            hostconfig->hugetlbs[i]->page_size = util_strdup_s(updateRes.hugepage_limits(i).page_size().c_str());
+            hostconfig->hugetlbs[i]->limit = updateRes.hugepage_limits(i).limit();
             hostconfig->hugetlbs_len++;
         }
     }
@@ -1121,6 +1187,12 @@ void ContainerManagerService::UpdateContainerResources(const std::string &contai
             error.SetError("Failed to call update container callback");
         }
     }
+#ifdef ENABLE_NRI
+    if (!NRIAdaptation::GetInstance()->PostUpdateContainer(containerID, nriErr)) {
+        ERROR("NRI PostUpdateContainer notification failed: %s", nriErr.GetCMessage());
+        goto cleanup;
+    }
+#endif
 cleanup:
     free_container_update_request(request);
     free_container_update_response(response);
diff --git a/src/daemon/entry/cri/v1/v1_cri_pod_sandbox_manager_service.cc b/src/daemon/entry/cri/v1/v1_cri_pod_sandbox_manager_service.cc
index 77faf48a..0140eb99 100644
--- a/src/daemon/entry/cri/v1/v1_cri_pod_sandbox_manager_service.cc
+++ b/src/daemon/entry/cri/v1/v1_cri_pod_sandbox_manager_service.cc
@@ -37,6 +37,9 @@
 #include "transform.h"
 #include "isulad_config.h"
 #include "mailbox.h"
+#ifdef ENABLE_NRI
+#include "nri_adaption.h"
+#endif
 
 namespace CRIV1 {
 void PodSandboxManagerService::PrepareSandboxData(const runtime::v1::PodSandboxConfig &config,
@@ -304,6 +307,9 @@ auto PodSandboxManagerService::RunPodSandbox(const runtime::v1::PodSandboxConfig
     std::string network_setting_json;
     runtime::v1::PodSandboxConfig copyConfig = config;
     cri_container_message_t msg = { 0 };
+#ifdef ENABLE_NRI
+    Errors nriErr;
+#endif
 
     // Step 1: Parepare sandbox name, runtime and networkMode
     PrepareSandboxData(config, runtimeHandler, sandboxName, runtimeInfo, networkMode, error);
@@ -401,6 +407,14 @@ auto PodSandboxManagerService::RunPodSandbox(const runtime::v1::PodSandboxConfig
     msg.type = CRI_CONTAINER_MESSAGE_TYPE_STARTED;
     mailbox_publish(MAILBOX_TOPIC_CRI_CONTAINER, &msg);
 
+#ifdef ENABLE_NRI
+    if (!NRIAdaptation::GetInstance()->RunPodSandbox(sandbox, nriErr)) {
+        ERROR("NRI RunPodSandbox failed:  %s", nriErr.GetCMessage());
+        error.Errorf("NRI RunPodSandbox failed:  %s", nriErr.GetCMessage());
+        return response_id;
+    }
+#endif
+
     return sandbox->GetId();
 
 cleanup_network:
@@ -418,6 +432,11 @@ cleanup_sandbox:
     if (error.NotEmpty()) {
         ERROR("Failed to delete sandbox: %s", sandbox->GetId().c_str());
     }
+#ifdef ENABLE_NRI
+    if (!NRIAdaptation::GetInstance()->RemovePodSandbox(sandbox, nriErr)) {
+        DEBUG("NRI RemovePodSandbox failed:  %s", nriErr.GetCMessage());
+    }
+#endif
 
     return response_id;
 }
@@ -618,7 +637,15 @@ void PodSandboxManagerService::StopPodSandbox(const std::string &podSandboxID, E
         return;
     }
 
-    sandbox->Stop(sandbox::DEFAULT_STOP_TIMEOUT, error);
+    if (!sandbox->Stop(sandbox::DEFAULT_STOP_TIMEOUT, error)) {
+        return;
+    }
+#ifdef ENABLE_NRI
+    Errors nriStopPodErr;
+    if (!NRIAdaptation::GetInstance()->StopPodSandbox(sandbox, nriStopPodErr)) {
+        ERROR("NRI sandbox stop notification failed  %s", nriStopPodErr.GetCMessage());
+    }
+#endif
 }
 
 void PodSandboxManagerService::RemoveAllContainersInSandbox(const std::string &readSandboxID,
@@ -656,6 +683,9 @@ void PodSandboxManagerService::RemovePodSandbox(const std::string &podSandboxID,
 {
     std::vector<std::string> errors;
     std::string realSandboxID;
+#ifdef ENABLE_NRI
+    Errors nriErr;
+#endif
 
     if (m_cb == nullptr || m_cb->container.remove == nullptr) {
         ERROR("Unimplemented callback");
@@ -724,6 +754,11 @@ void PodSandboxManagerService::RemovePodSandbox(const std::string &podSandboxID,
         msg.type = CRI_CONTAINER_MESSAGE_TYPE_DELETED;
         mailbox_publish(MAILBOX_TOPIC_CRI_CONTAINER, &msg);
     }
+#ifdef ENABLE_NRI
+    if (!NRIAdaptation::GetInstance()->RemovePodSandbox(sandbox, nriErr)) {
+        ERROR("NRI RemovePodSandbox failed:  %s", nriErr.GetCMessage());
+    }
+#endif
 }
 
 auto PodSandboxManagerService::SharesHostNetwork(const container_inspect *inspect) -> runtime::v1::NamespaceMode
diff --git a/src/daemon/executor/container_cb/execution_create.c b/src/daemon/executor/container_cb/execution_create.c
index 2b6b2a15..dcbdd1d3 100644
--- a/src/daemon/executor/container_cb/execution_create.c
+++ b/src/daemon/executor/container_cb/execution_create.c
@@ -65,6 +65,10 @@
 #include "mailbox.h"
 #include "specs_mount.h"
 
+#ifdef ENABLE_NRI
+#include "nri_spec.h"
+#endif
+
 #ifdef ENABLE_CRI_API_V1
 static bool validate_sandbox_info(const container_sandbox_info *sandbox)
 {
@@ -1465,6 +1469,14 @@ int container_create_cb(const container_create_request *request, container_creat
     skip_sandbox_key_manage = (is_sandbox_container(request->sandbox) && namespace_is_cni(host_spec->network_mode));
 #endif
 
+#ifdef ENABLE_NRI
+    if (request->adjust != NULL && nri_adjust_host_spec(request->adjust, host_spec) != 0) {
+        ERROR("Failed to adjust host spec");
+        cc = ISULAD_ERR_INPUT;
+        goto clean_container_root_dir;
+    }
+#endif
+
     if (save_container_config_before_create(id, runtime_root, host_spec, v2_spec) != 0) {
         ERROR("Failed to malloc container_config_v2_common_config");
         cc = ISULAD_ERR_INPUT;
@@ -1553,6 +1565,15 @@ int container_create_cb(const container_create_request *request, container_creat
     }
 #endif
 
+#ifdef ENABLE_NRI
+    // modify oci spec by nri plugin
+    if (request->adjust != NULL && nri_adjust_oci_spec(request->adjust, oci_spec) != 0) {
+        ERROR("Failed to adjust oci spec");
+        cc = ISULAD_ERR_EXEC;
+        goto clean_netns;
+    }
+#endif
+
     host_channel = dup_host_channel(host_spec->host_channel);
     if (prepare_host_channel(host_channel, host_spec->user_remap)) {
         ERROR("Failed to prepare host channel");
diff --git a/src/daemon/modules/service/service_container.c b/src/daemon/modules/service/service_container.c
index 0b95cdad..4157c631 100644
--- a/src/daemon/modules/service/service_container.c
+++ b/src/daemon/modules/service/service_container.c
@@ -76,6 +76,9 @@
 #include "sandbox_ops.h"
 #include "vsock_io_handler.h"
 #endif
+#ifdef ENABLE_NRI
+#include "nri_spec.h"
+#endif
 
 #define KATA_RUNTIME "kata-runtime"
 
@@ -726,6 +729,15 @@ static int do_oci_spec_update(const char *id, oci_runtime_spec *oci_spec, contai
         return -1;
     }
 
+#ifdef ENABLE_NRI
+    // update oci spec with nri
+    ret = update_oci_nri(oci_spec, hostconfig);
+    if (ret != 0) {
+        ERROR("Failed to update oci spec with nri");
+        return -1;
+    }
+#endif
+
     // renew_oci_config() will update process->user and share namespace after.
 
     return 0;
diff --git a/src/daemon/modules/spec/specs.c b/src/daemon/modules/spec/specs.c
index 002431d8..36e89343 100644
--- a/src/daemon/modules/spec/specs.c
+++ b/src/daemon/modules/spec/specs.c
@@ -2883,7 +2883,12 @@ int spec_add_linux_resources_rlimit(oci_runtime_spec *oci_spec, const char *type
         return -1;
     }
 
-    ret = make_sure_oci_spec_linux_resources(oci_spec);
+    ret = make_sure_oci_spec_process(oci_spec);
+    if (ret < 0) {
+        return -1;
+    }
+
+    ret = merge_ulimits_pre(oci_spec, 1);
     if (ret < 0) {
         return -1;
     }
diff --git a/src/daemon/nri/nri_adaption.cc b/src/daemon/nri/nri_adaption.cc
new file mode 100644
index 00000000..3190767f
--- /dev/null
+++ b/src/daemon/nri/nri_adaption.cc
@@ -0,0 +1,1165 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2024. All rights reserved.
+ * iSulad licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *     http://license.coscl.org.cn/MulanPSL2
+ * 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 v2 for more details.
+ * Author: zhongtao
+ * Create: 2024-03-15
+ * Description: provide plugin manager(NRI adaption) class definition
+ *********************************************************************************/
+
+#include "nri_adaption.h"
+
+#include <sys/stat.h>
+
+#include <isula_libutils/log.h>
+#include <isula_libutils/auto_cleanup.h>
+
+#include "isulad_config.h"
+#include "utils_file.h"
+#include "utils_string.h"
+#include "utils.h"
+#include "nri_convert.h"
+#include "nri_plugin.h"
+#include "nri_result.h"
+#include "sandbox_manager.h"
+
+std::atomic<NRIAdaptation *> NRIAdaptation::m_instance;
+
+NRIAdaptation *NRIAdaptation::GetInstance() noexcept
+{
+    static std::once_flag flag;
+
+    std::call_once(flag, [] { m_instance = new NRIAdaptation; });
+
+    return m_instance;
+}
+
+NRIAdaptation::~NRIAdaptation()
+{
+    for (const auto &pair : m_storeMap) {
+        auto plugin = pair.second;
+        plugin->shutdown();
+    }
+}
+
+auto NRIAdaptation::Init(Errors &error) -> bool
+{
+    std::map<std::string, std::shared_ptr<NRIPlugin>> tmp_storeMap;
+
+    m_support = conf_get_nri_support();
+    if (!m_support) {
+        return true;
+    }
+
+    m_external_support = conf_get_nri_external_support();
+    service_executor_t *cb = get_service_executor();
+    if (cb == nullptr) {
+        ERROR("Init isulad service executor failure.");
+        return false;
+    }
+
+    m_containerManager = std::make_unique<CRIV1::ContainerManagerService>(cb);
+
+    m_pluginConfigPath = GetNRIPluginConfigPath();
+    m_pluginPath = GetNRIPluginPath();
+    m_plugin_registration_timeout = conf_get_nri_plugin_registration_timeout();
+    m_plugin_requst_timeout = conf_get_nri_plugin_requst_timeout();
+    m_sock_path = GetNRISockPath();
+
+    if (!StartPlugin()) {
+        ERROR("Failed to do StartPlugin");
+        return false;
+    }
+
+    if (!SortPlugins()) {
+        ERROR("Failed to do SortPlugins");
+        return false;
+    }
+
+    return true;
+}
+
+void NRIAdaptation::RemoveClosedPlugins()
+{
+    std::vector<std::string> closedPlugin;
+
+    GetClosedPlugins(closedPlugin);
+
+    for (const auto &key : closedPlugin) {
+        RemovePluginByIndex(key);
+    }
+}
+
+void NRIAdaptation::GetClosedPlugins(std::vector<std::string> &closedPlugin)
+{
+    ReadGuard<RWMutex> lock(m_mutex);
+    for (const auto &pair : m_storeMap) {
+        auto plugin = pair.second;
+        if (plugin->IsClose()) {
+            closedPlugin.push_back(pair.first);
+        }
+    }
+}
+
+auto NRIAdaptation::IsSupport() -> bool
+{
+    return m_support;
+}
+
+auto NRIAdaptation::GetPluginByIndex(const std::string &index) -> std::shared_ptr<NRIPlugin>
+{
+    ReadGuard<RWMutex> lock(m_mutex);
+    return m_storeMap[index];
+}
+
+void NRIAdaptation::RemovePluginByIndex(const std::string &index)
+{
+    WriteGuard<RWMutex> lock(m_mutex);
+    m_storeMap.erase(index);
+}
+
+void NRIAdaptation::AddPluginByIndex(const std::string &index, std::shared_ptr<NRIPlugin> plugin)
+{
+    WriteGuard<RWMutex> lock(m_mutex);
+    m_storeMap[index] = plugin;
+}
+
+auto NRIAdaptation::ApplyUpdates(const std::vector<nri_container_update *> &update,
+                                 std::vector<nri_container_update *> &failed, bool getFailed, Errors &error) -> bool
+{
+    for (auto &u : update) {
+        runtime::v1::LinuxContainerResources resources;
+        if (!LinuxResourcesFromNRI(u->linux->resources, resources)) {
+            ERROR("Failed to convert Linux resources from NRI");
+            error.Errorf("Failed to convert Linux resources from NRI");
+            return false;
+        }
+
+        m_containerManager->UpdateContainerResources(u->container_id, resources, error);
+
+        if (error.NotEmpty()) {
+            ERROR("Failed to update container: %s resources: %s", u->container_id, error.GetCMessage());
+            if (!u->ignore_failure && getFailed) {
+                failed.push_back(u);
+            }
+            continue;
+        }
+
+        TRACE("NRI update of container %s successful", u->container_id);
+    }
+
+    if (failed.size() != 0) {
+        error.Errorf("NRI update of some containers failed");
+        return false;
+    }
+    return true;
+}
+
+auto NRIAdaptation::NewExternalPlugin(int fd) -> bool
+{
+    if (!m_external_support) {
+        ERROR("External plugin support is disabled");
+        return false;
+    }
+    if (fd < 0) {
+        ERROR("Invalid fd");
+        return false;
+    }
+
+    std::string plugin_name;
+    NRIHelpers::GenerateRandomExternalName(plugin_name);
+    if (plugin_name.empty()) {
+        ERROR("Failed to generate random external name");
+        return false;
+    }
+
+    auto plugin = std::make_shared<NRIPlugin>(fd, plugin_name);
+
+    AddPluginByIndex(plugin_name, plugin);
+
+    if (!plugin->Start(m_plugin_registration_timeout, m_plugin_requst_timeout)) {
+        ERROR("Failed to start plugin ready for conn fd %d", fd);
+        RemovePluginByIndex(plugin_name);
+        return false;
+    }
+
+    std::vector<nri_pod_sandbox *> pods;
+    std::vector<nri_container *> cons;
+    nri_container_update **updateRes;
+    size_t update_len = 0;
+
+    std::vector<std::shared_ptr<sandbox::Sandbox>> sandboxes;
+    runtime::v1::PodSandboxFilter podFilter;
+    std::vector<std::unique_ptr<runtime::v1::Container>> containers;
+    Errors tmpError;
+
+    std::vector<nri_container_update *> updates;
+    std::vector<nri_container_update *> failed;
+
+    sandbox::SandboxManager::GetInstance()->ListAllSandboxes(podFilter, sandboxes);
+
+    if (!PodSandboxesToNRI(sandboxes, pods)) {
+        ERROR("Failed to convert podsandbox to nri");
+        NRIHelpers::FreeNriPodVector(pods);
+        return false;
+    }
+
+    m_containerManager->ListContainers(nullptr, containers, tmpError);
+
+    if (!ContainersToNRI(containers, cons)) {
+        ERROR("Failed to convert container to nri");
+        NRIHelpers::FreeNriPodVector(pods);
+        NRIHelpers::FreeNriContainerVector(cons);
+        return false;
+    }
+
+    // pods and cons's memory transfer to nri_synchronize_request,
+    // and is automatically freed when nri_synchronize_request is freed
+    if (!plugin->Synchronize(pods, cons, &updateRes, update_len, tmpError)) {
+        ERROR("Failed to synchronize plugin");
+        return false;
+    }
+
+    for (size_t i = 0; i < update_len; i++) {
+        updates.push_back(updateRes[i]);
+    }
+
+    if (!ApplyUpdates(updates, failed, false, tmpError)) {
+        ERROR("Failed to update post-sync");
+    }
+
+    NRIHelpers::FreeNriContainerUpdateVector(updates);
+    NRIHelpers::FreeNriContainerUpdateVector(failed);
+    INFO("plugin %s connected", plugin_name.c_str());
+    return true;
+}
+
+auto NRIAdaptation::RunPodSandbox(std::shared_ptr<const sandbox::Sandbox> sandbox, Errors &error) -> bool
+{
+    if (!m_support) {
+        return true;
+    }
+
+    auto pod = NRIPodSandbox(sandbox, error);
+    if (pod == nullptr) {
+        ERROR("Failed to covert podsandbox to nri: %s", sandbox->GetId().c_str());
+        return false;
+    }
+
+    auto runPodEvent = makeUniquePtrCStructWrapper<nri_state_change_event>(free_nri_state_change_event);
+    if (runPodEvent == nullptr) {
+        ERROR("Out of memory");
+        return false;
+    }
+
+    runPodEvent->get()->pod = pod->move();
+    runPodEvent->get()->event = RUN_POD_SANDBOX;
+    return StateChange(runPodEvent->get(), error);
+}
+
+auto NRIAdaptation::StopPodSandbox(std::shared_ptr<const sandbox::Sandbox> sandbox, Errors &error) -> bool
+{
+    if (!m_support) {
+        return true;
+    }
+
+    auto pod = NRIPodSandbox(sandbox, error);
+    if (pod == nullptr) {
+        ERROR("Failed to covert podsandbox to nri: %s", sandbox->GetId().c_str());
+        return false;
+    }
+
+    auto stopPodEvent = makeUniquePtrCStructWrapper<nri_state_change_event>(free_nri_state_change_event);
+    if (stopPodEvent == nullptr) {
+        ERROR("Out of memory");
+        return false;
+    }
+
+    stopPodEvent->get()->pod = pod->move();
+    stopPodEvent->get()->event = STOP_POD_SANDBOX;
+    return StateChange(stopPodEvent->get(), error);
+}
+
+auto NRIAdaptation::RemovePodSandbox(std::shared_ptr<const sandbox::Sandbox> sandbox, Errors &error) -> bool
+{
+    if (!m_support) {
+        return true;
+    }
+
+    auto pod = NRIPodSandbox(sandbox, error);
+    if (pod == nullptr) {
+        ERROR("Failed to covert podsandbox to nri: %s", sandbox->GetId().c_str());
+        return false;
+    }
+
+    auto removePodEvent = makeUniquePtrCStructWrapper<nri_state_change_event>(free_nri_state_change_event);
+    if (removePodEvent == nullptr) {
+        ERROR("Out of memory");
+        return false;
+    }
+
+    removePodEvent->get()->pod = pod->move();
+    removePodEvent->get()->event = REMOVE_POD_SANDBOX;
+    return StateChange(removePodEvent->get(), error);
+}
+
+auto NRIAdaptation::CreateContainer(std::shared_ptr<const sandbox::Sandbox> sandbox, const std::string &conId,
+                                    const runtime::v1::ContainerConfig &containerConfig, nri_container_adjustment **adjust, Errors &error) -> bool
+{
+    if (!m_support) {
+        return true;
+    }
+
+    auto pod = NRIPodSandbox(sandbox, error);
+    if (pod == nullptr) {
+        ERROR("Failed to covert podsandbox to nri: %s", sandbox->GetId().c_str());
+        return false;
+    }
+
+    auto con = NRIContainerByConConfig(sandbox, containerConfig, error);
+    if (con == nullptr) {
+        ERROR("Failed to covert container to nri: %s", conId.c_str());
+        return false;
+    }
+
+    auto req = makeUniquePtrCStructWrapper<nri_create_container_request>(free_nri_create_container_request);
+    if (req == nullptr) {
+        ERROR("Out of memory");
+        return false;
+    }
+
+    req->get()->container = con->move();
+    req->get()->pod = pod->move();
+
+    pluginResult result;
+    result.InitByConId(conId);
+
+    if (!PluginsCreateContainer(req->get(), conId, result)) {
+        ERROR("Failed to call create container to all plugins");
+        return false;
+    }
+
+    RemoveClosedPlugins();
+
+    // TODO:evict container do not aply
+
+    // TODO:how can i rollback on failure
+    std::vector<nri_container_update *> failed;
+    if (!ApplyUpdates(result.GetReplyUpdate(), failed, false, error)) {
+        ERROR("Failed to apply updates");
+        NRIHelpers::FreeNriContainerUpdateVector(failed);
+        return false;
+    }
+
+    *adjust = result.MoveReplyAdjust();
+    NRIHelpers::FreeNriContainerUpdateVector(failed);
+    return true;
+}
+
+bool NRIAdaptation::PluginsCreateContainer(nri_create_container_request *req, const std::string &conId,
+                                           pluginResult &result)
+{
+    ReadGuard<RWMutex> lock(m_mutex);
+
+    for (const auto &pair : m_storeMap) {
+        auto plugin = pair.second;
+        Errors tmpError;
+        nri_create_container_response *resp = nullptr;
+
+        if (!plugin->CreateContainer(req, &resp, tmpError)) {
+            ERROR("Failed to call create container: %s to pliugin: %s", conId.c_str(), plugin->GetName().c_str());
+            (void)plugin->shutdown();
+            continue;
+        }
+
+        if (resp == nullptr) {
+            ERROR("Empty CreateContainer resp : %s", plugin->GetName().c_str());
+            continue;
+        }
+
+        auto resp_wrapper =
+            makeUniquePtrCStructWrapper<nri_create_container_response>(resp, free_nri_create_container_response);
+        if (resp_wrapper == nullptr) {
+            ERROR("Out of memory");
+            return false;
+        }
+
+        result.Apply(CREATE_CONTAINER, resp_wrapper->get()->adjust, resp_wrapper->get()->update,
+                     resp_wrapper->get()->update_len, plugin->GetName());
+    }
+    return true;
+}
+
+auto NRIAdaptation::PostCreateContainer(const std::string &conId, Errors &error) -> bool
+{
+    if (!m_support) {
+        return true;
+    }
+
+    auto con = NRIContainerByID(conId, error);
+    if (con == nullptr) {
+        ERROR("Failed to covert container to nri: %s", conId.c_str());
+        return false;
+    }
+
+    auto sandbox = sandbox::SandboxManager::GetInstance()->GetSandbox(con->get()->pod_sandbox_id);
+    if (sandbox == nullptr) {
+        ERROR("Failed to get sandbox info for nri");
+        return false;
+    }
+
+    auto pod = NRIPodSandbox(sandbox, error);
+    if (pod == nullptr) {
+        ERROR("Failed to covert podsandbox to nri: %s", sandbox->GetId().c_str());
+        return false;
+    }
+
+    auto postCreateConEvent = makeUniquePtrCStructWrapper<nri_state_change_event>(free_nri_state_change_event);
+    if (postCreateConEvent == nullptr) {
+        ERROR("Out of memory");
+        return false;
+    }
+
+    postCreateConEvent->get()->container = con->move();
+    postCreateConEvent->get()->pod = pod->move();
+    postCreateConEvent->get()->event = POST_CREATE_CONTAINER;
+    return StateChange(postCreateConEvent->get(), error);
+}
+
+auto NRIAdaptation::StartContainer(const std::string &conId, Errors &error) -> bool
+{
+    if (!m_support) {
+        return true;
+    }
+
+    auto con = NRIContainerByID(conId, error);
+    if (con == nullptr) {
+        ERROR("Failed to covert container to nri: %s", conId.c_str());
+        return false;
+    }
+
+    auto sandbox = sandbox::SandboxManager::GetInstance()->GetSandbox(con->get()->pod_sandbox_id);
+    if (sandbox == nullptr) {
+        ERROR("Failed to get sandbox info for nri");
+        return false;
+    }
+
+    if (sandbox == nullptr) {
+        ERROR("Failed to get sandbox for container: %s, sandbox id: %s", conId.c_str(), con->get()->pod_sandbox_id);
+        return false;
+    }
+
+    auto pod = NRIPodSandbox(sandbox, error);
+    if (pod == nullptr) {
+        ERROR("Failed to covert podsandbox to nri: %s", sandbox->GetId().c_str());
+        return false;
+    }
+
+    auto startConEvent = makeUniquePtrCStructWrapper<nri_state_change_event>(free_nri_state_change_event);
+    if (startConEvent == nullptr) {
+        ERROR("Out of memory");
+        return false;
+    }
+
+    startConEvent->get()->container = con->move();
+    startConEvent->get()->pod = pod->move();
+    startConEvent->get()->event = START_CONTAINER;
+    return StateChange(startConEvent->get(), error);
+}
+
+auto NRIAdaptation::PostStartContainer(const std::string &conId, Errors &error) -> bool
+{
+    if (!m_support) {
+        return true;
+    }
+
+    auto con = NRIContainerByID(conId, error);
+    if (con == nullptr) {
+        ERROR("Failed to covert container to nri: %s", conId.c_str());
+        return false;
+    }
+
+    auto sandbox = sandbox::SandboxManager::GetInstance()->GetSandbox(con->get()->pod_sandbox_id);
+    if (sandbox == nullptr) {
+        ERROR("Failed to get sandbox info for nri");
+        return false;
+    }
+
+    auto pod = NRIPodSandbox(sandbox, error);
+    if (pod == nullptr) {
+        ERROR("Failed to covert podsandbox to nri: %s", sandbox->GetId().c_str());
+        return false;
+    }
+
+    auto postStartConEvent = makeUniquePtrCStructWrapper<nri_state_change_event>(free_nri_state_change_event);
+    if (postStartConEvent == nullptr) {
+        ERROR("Out of memory");
+        return false;
+    }
+
+    postStartConEvent->get()->container = con->move();
+    postStartConEvent->get()->pod = pod->move();
+    postStartConEvent->get()->event = POST_START_CONTAINER;
+    return StateChange(postStartConEvent->get(), error);
+}
+
+auto NRIAdaptation::UndoCreateContainer(std::shared_ptr<const sandbox::Sandbox> sandbox, const std::string &conId,
+                                        Errors &error) -> bool
+{
+    if (!m_support) {
+        return true;
+    }
+
+    if (!StopContainer(conId, error)) {
+        ERROR("container creation undo (stop) failed: %s", conId.c_str());
+    }
+
+    if (!RemoveContainer(conId, error)) {
+        ERROR("container creation undo (remove) failed: %s", conId.c_str());
+    }
+
+    return true;
+}
+
+auto NRIAdaptation::UpdateContainer(const std::string &conId, const runtime::v1::LinuxContainerResources &resources,
+                                    runtime::v1::LinuxContainerResources &adjust, Errors &error) -> bool
+{
+    if (!m_support) {
+        return true;
+    }
+
+    auto con = NRIContainerByID(conId, error);
+    if (con == nullptr) {
+        ERROR("Failed to covert container to nri: %s", conId.c_str());
+        return false;
+    }
+
+    auto sandbox = sandbox::SandboxManager::GetInstance()->GetSandbox(con->get()->pod_sandbox_id);
+    if (sandbox == nullptr) {
+        ERROR("Failed to get sandbox info for nri");
+        return false;
+    }
+
+    auto pod = NRIPodSandbox(sandbox, error);
+    if (pod == nullptr) {
+        ERROR("Failed to covert podsandbox to nri: %s", sandbox->GetId().c_str());
+        return false;
+    }
+
+    auto req = makeUniquePtrCStructWrapper<nri_update_container_request>(free_nri_update_container_request);
+    if (req == nullptr) {
+        ERROR("Out of memory");
+        return false;
+    }
+
+    auto reqRes = LinuxResourcesToNRI(resources);
+
+    req->get()->container = con->move();
+    req->get()->pod = pod->move();
+    req->get()->linux_resources = reqRes;
+
+    pluginResult result;
+    result.InitByUpdateReq(req->get());
+
+    if (!PluginsUpdateContainer(req->get(), conId, result)) {
+        ERROR("Failed to call update container to all plugins");
+        return false;
+    }
+
+    RemoveClosedPlugins();
+
+    // TODO:evict container do not aply
+
+    // TODO:how can i rollback on failure
+    std::vector<nri_container_update *> failed;
+    if (!ApplyUpdates(result.GetReplyUpdate(), failed, false, error)) {
+        ERROR("Failed to apply updates");
+        NRIHelpers::FreeNriContainerUpdateVector(failed);
+        return false;
+    }
+
+    NRIHelpers::FreeNriContainerUpdateVector(failed);
+
+    if (!LinuxResourcesFromNRI(result.GetReplyResources(conId), adjust)) {
+        ERROR("Failed to convert Linux resources from NRI");
+        return false;
+    }
+
+    return true;
+}
+
+bool NRIAdaptation::PluginsUpdateContainer(nri_update_container_request *req, const std::string &conId,
+                                           pluginResult &result)
+{
+    ReadGuard<RWMutex> lock(m_mutex);
+
+    for (const auto &pair : m_storeMap) {
+        auto plugin = pair.second;
+        Errors tmpError;
+        nri_update_container_response *resp = nullptr;
+
+        if (!plugin->UpdateContainer(req, &resp, tmpError)) {
+            ERROR("Failed to call create container: %s to pliugin: %s", conId.c_str(), plugin->GetName().c_str());
+            plugin->shutdown();
+            continue;
+        }
+
+        if (resp == nullptr) {
+            ERROR("Empty UpdateContainer resp : %s", plugin->GetName().c_str());
+            continue;
+        }
+
+        auto resp_wrapper =
+            makeUniquePtrCStructWrapper<nri_update_container_response>(resp, free_nri_update_container_response);
+        if (resp_wrapper == nullptr) {
+            ERROR("Out of memory");
+            return false;
+        }
+
+        result.Apply(UPDATE_CONTAINER, nullptr, resp_wrapper->get()->update, resp_wrapper->get()->update_len,
+                     plugin->GetName());
+    }
+    return true;
+}
+
+bool NRIAdaptation::PluginsStopContainer(nri_stop_container_request *req, const std::string &conId,
+                                         pluginResult &result)
+{
+    ReadGuard<RWMutex> lock(m_mutex);
+
+    for (const auto &pair : m_storeMap) {
+        auto plugin = pair.second;
+        Errors tmpError;
+        nri_stop_container_response *resp = nullptr;
+
+        if (!plugin->StopContainer(req, &resp, tmpError)) {
+            ERROR("Failed to call create container: %s to pliugin: %s", conId.c_str(), plugin->GetName().c_str());
+            plugin->shutdown();
+            continue;
+        }
+
+        if (resp == nullptr) {
+            ERROR("Empty StopContainer resp : %s", plugin->GetName().c_str());
+            continue;
+        }
+
+        auto resp_wrapper = makeUniquePtrCStructWrapper<nri_stop_container_response>(resp, free_nri_stop_container_response);
+        if (resp_wrapper == nullptr) {
+            ERROR("Out of memory");
+            return false;
+        }
+
+        result.Apply(STOP_CONTAINER, nullptr, resp_wrapper->get()->update, resp_wrapper->get()->update_len, plugin->GetName());
+    }
+    return true;
+}
+
+auto NRIAdaptation::PostUpdateContainer(const std::string &conId, Errors &error) ->bool
+{
+    if (!m_support) {
+        return true;
+    }
+
+    auto con = NRIContainerByID(conId, error);
+    if (con == nullptr) {
+        ERROR("Failed to covert container to nri: %s", conId.c_str());
+        return false;
+    }
+
+    auto sandbox = sandbox::SandboxManager::GetInstance()->GetSandbox(con->get()->pod_sandbox_id);
+    if (sandbox == nullptr) {
+        ERROR("Failed to get sandbox info for nri");
+        return false;
+    }
+
+    auto pod = NRIPodSandbox(sandbox, error);
+    if (pod == nullptr) {
+        ERROR("Failed to covert podsandbox to nri: %s", sandbox->GetId().c_str());
+        return false;
+    }
+
+    auto postUpdateConEvent = makeUniquePtrCStructWrapper<nri_state_change_event>(free_nri_state_change_event);
+    if (postUpdateConEvent == nullptr) {
+        ERROR("Out of memory");
+        return false;
+    }
+
+    postUpdateConEvent->get()->container = con->move();
+    postUpdateConEvent->get()->pod = pod->move();
+    postUpdateConEvent->get()->event = POST_UPDATE_CONTAINER;
+    return StateChange(postUpdateConEvent->get(), error);
+}
+
+auto NRIAdaptation::StopContainer(const std::string &conId, Errors &error) ->bool
+{
+    if (!m_support) {
+        return true;
+    }
+
+    auto con = NRIContainerByID(conId, error);
+    if (con == nullptr) {
+        ERROR("Failed to covert container to nri: %s", conId.c_str());
+        return false;
+    }
+
+    auto sandbox = sandbox::SandboxManager::GetInstance()->GetSandbox(con->get()->pod_sandbox_id);
+    if (sandbox == nullptr) {
+        ERROR("Failed to get sandbox info for nri");
+        return false;
+    }
+
+    auto pod = NRIPodSandbox(sandbox, error);
+    if (pod == nullptr) {
+        ERROR("Failed to covert podsandbox to nri: %s", sandbox->GetId().c_str());
+        return false;
+    }
+
+    auto req = makeUniquePtrCStructWrapper<nri_stop_container_request>(free_nri_stop_container_request);
+    if (req == nullptr) {
+        ERROR("Out of memory");
+        return false;
+    }
+
+    req->get()->pod = pod->move();
+    req->get()->container = con->move();
+
+    pluginResult result;
+    result.Init();
+
+    if (!PluginsStopContainer(req->get(), conId, result)) {
+        ERROR("Failed to call stop container to all plugins");
+        return false;
+    }
+
+    RemoveClosedPlugins();
+
+    // TODO:how can i rollback on failure
+    std::vector<nri_container_update *> failed;
+    if (!ApplyUpdates(result.GetReplyUpdate(), failed, false, error)) {
+        ERROR("Failed to apply updates");
+        NRIHelpers::FreeNriContainerUpdateVector(failed);
+        return false;
+    }
+
+    NRIHelpers::FreeNriContainerUpdateVector(failed);
+    return true;
+}
+
+auto NRIAdaptation::RemoveContainer(const std::string &conId, Errors &error) ->bool
+{
+    if (!m_support) {
+        return true;
+    }
+
+    auto con = NRIContainerByID(conId, error);
+    if (con == nullptr) {
+        ERROR("Failed to covert container to nri: %s", conId.c_str());
+        return false;
+    }
+
+    auto sandbox = sandbox::SandboxManager::GetInstance()->GetSandbox(con->get()->pod_sandbox_id);
+    if (sandbox == nullptr) {
+        ERROR("Failed to get sandbox info for nri");
+        return false;
+    }
+
+    auto pod = NRIPodSandbox(sandbox, error);
+    if (pod == nullptr) {
+        ERROR("Failed to covert podsandbox to nri: %s", sandbox->GetId().c_str());
+        return false;
+    }
+
+    auto removeConEvent = makeUniquePtrCStructWrapper<nri_state_change_event>(free_nri_state_change_event);
+    if (removeConEvent == nullptr) {
+        ERROR("Out of memory");
+        return false;
+    }
+
+    removeConEvent->get()->container = con->move();
+    removeConEvent->get()->pod = pod->move();
+    removeConEvent->get()->event = REMOVE_CONTAINER;
+    return StateChange(removeConEvent->get(), error);
+}
+
+auto NRIAdaptation::StateChange(nri_state_change_event *evt, Errors &error) ->bool
+{
+    if (evt->event == UNKNOWN) {
+        ERROR("invalid (unset) event in state change notification");
+        error.SetError("invalid (unset) event in state change notification");
+        return false;
+    }
+
+    PluginsStateChange(evt);
+
+    RemoveClosedPlugins();
+    return true;
+}
+
+void NRIAdaptation::PluginsStateChange(nri_state_change_event *evt)
+{
+    ReadGuard<RWMutex> lock(m_mutex);
+
+    for (const auto &pair : m_storeMap) {
+        auto plugin = pair.second;
+        Errors tmpError;
+        if (!plugin->StateChange(evt, tmpError)) {
+            ERROR("invalid (unset) event in state change notification: %s", plugin->GetName().c_str());
+            plugin->shutdown();
+            continue;
+        }
+    }
+}
+
+// Perform a set of unsolicited container updates requested by a plugin.
+auto NRIAdaptation::updateContainers(const nri_update_containers_request *req,
+                                     nri_update_containers_response **resp) ->bool
+{
+    std::vector<nri_container_update *> failed;
+    std::vector<nri_container_update *> vec;
+    size_t i;
+    Errors error;
+    bool ret = false;
+
+    if (req == nullptr) {
+        ERROR("Invalid request");
+        return false;
+    }
+
+    for (i = 0; i < req->update_len; i++) {
+        vec.push_back(req->update[i]);
+    }
+
+    if (!ApplyUpdates(vec, failed, false, error)) {
+        ERROR("Failed to apply updates: %s", error.GetCMessage());
+        goto free_out;
+    }
+
+    if (failed.size() == 0) {
+        ret = true;
+        goto free_out;
+    }
+
+    (*resp)->failed = (nri_container_update **)util_common_calloc_s(failed.size() * sizeof(nri_container_update *));
+    if ((*resp)->failed == nullptr) {
+        ERROR("Out of memory");
+        goto free_out;
+    }
+
+    for (i = 0; i < failed.size(); i++) {
+        (*resp)->failed[i] = failed[i];
+        failed[i] = nullptr;
+        (*resp)->failed_len++;
+    }
+    ret = true;
+
+free_out:
+    NRIHelpers::FreeNriContainerUpdateVector(vec);
+    NRIHelpers::FreeNriContainerUpdateVector(failed);
+    return ret;
+}
+
+auto NRIAdaptation::StartPlugin() -> bool
+{
+    std::map<std::string, std::shared_ptr<NRIPlugin>> tmp_storeMap;
+
+    if (!DiscoverPlugins(tmp_storeMap) != 0) {
+        ERROR("Failed to do DiscoverPlugins");
+        return false;
+    }
+
+    for (const auto &pair : tmp_storeMap) {
+        const std::string &index = pair.first;
+        auto plugin = pair.second;
+
+        if (!NewLaunchedPlugin(plugin)) {
+            ERROR("Failed to do NewLaunchedPlugin for %s", plugin->GetName().c_str());
+            continue;
+        }
+
+        AddPluginByIndex(index, plugin);
+
+        if (!plugin->Start(m_plugin_registration_timeout, m_plugin_requst_timeout)) {
+            ERROR("Failed to start plugin %s ready", plugin->GetName().c_str());
+            RemovePluginByIndex(index);
+            (void)plugin->shutdown();
+            continue;
+        }
+    }
+
+    return true;
+}
+
+// return true always, failure to obtain one plugin does not affect other plugin
+static auto walk_plugin_dir_cb(const char *path_name, const struct dirent *sub_dir, void *context) -> bool
+{
+    std::string full_path = std::string(path_name) + "/" + sub_dir->d_name;
+    struct stat file_stat = { 0 };
+
+    if (stat(full_path.c_str(), &file_stat) != 0) {
+        WARN("Failed to get NRI plugin %s stat", sub_dir->d_name);
+        return true;
+    }
+
+    if (S_ISDIR(file_stat.st_mode)) {
+        INFO("Skip dir in plugin path %s", sub_dir->d_name);
+        return true;
+    }
+
+    // 1. Verify plugin permissions for exec
+    if (!(file_stat.st_mode & S_IXUSR)) {
+        ERROR("NRI plugin %s has no permission for exec", sub_dir->d_name);
+        return true;
+    }
+
+    // 2. Parse plugin name
+    __isula_auto_array_t char **arr = util_string_split_n(sub_dir->d_name, '-', 2);
+    if (arr == nullptr) {
+        ERROR("Invalid plugin name %s, idx-pluginname expected", sub_dir->d_name);
+        return true;
+    }
+
+    if (!NRIHelpers::CheckPluginIndex(arr[0])) {
+        ERROR("Invalid plugin name %s, invalid idx", sub_dir->d_name);
+        return true;
+    }
+
+    // 3. init plugin
+    std::string index(arr[0]);
+    std::string pluginName(arr[1]);
+    std::string config;
+
+    std::map<std::string, std::shared_ptr<NRIPlugin>> &map =
+                                                       *static_cast<std::map<std::string, std::shared_ptr<NRIPlugin>>*>(context);
+    if (!NRIHelpers::GetPluginConfig(index, pluginName, config)) {
+        ERROR("Failed to get plugin %s config", pluginName.c_str());
+        return true;
+    }
+
+    auto plugin = std::make_shared<NRIPlugin>(index, pluginName, config);
+
+    // todo:use random id str
+    map[pluginName] = plugin;
+    return true;
+}
+
+static void plugin_exec_func(nri_plugin_exec_args_t * plugin_args)
+{
+    const char *params[PARAM_NUM] = {0};
+    int i = 0;
+    std::string sock = std::to_string(plugin_args->sockFd);
+
+    if (plugin_args == nullptr) {
+        ERROR("Missing plugin exec info");
+        _exit(EXIT_FAILURE);
+    }
+
+    if (chdir(plugin_args->workdir) < 0) {
+        ERROR("Failed to chdir to %s", plugin_args->workdir);
+        _exit(EXIT_FAILURE);
+    }
+
+    if (setenv(PluginNameEnv.c_str(), plugin_args->name, 1) != 0) {
+        ERROR("%s: failed to set PluginNameEnv for process %d", plugin_args->name, getpid());
+        exit(EXIT_FAILURE);
+    }
+
+    if (setenv(PluginIdxEnv.c_str(), plugin_args->index, 1) != 0) {
+        ERROR("%s: failed to set PluginIdxEnv for process %d", plugin_args->name, getpid());
+        exit(EXIT_FAILURE);
+    }
+
+    if (setenv(PluginSocketEnv.c_str(), sock.c_str(), 1) != 0) {
+        ERROR("%s: failed to set PluginSocketEnv for process %d", plugin_args->name, getpid());
+        exit(EXIT_FAILURE);
+    }
+
+    if (util_check_inherited(true, plugin_args->sockFd) != 0) {
+        ERROR("Failed to close inherited fds");
+        exit(EXIT_FAILURE);
+    }
+
+    if (setsid() < 0) {
+        ERROR("Failed to setsid for nri plugin: %s", plugin_args->name);
+        exit(EXIT_FAILURE);
+    }
+
+    params[i++] = plugin_args->name;
+
+    execvp(plugin_args->cmd, (char * const *)params);
+    ERROR("Failed to exec %s", plugin_args->cmd);
+    _exit(EXIT_FAILURE);
+}
+
+// create socket, and call plugin start
+auto NRIAdaptation::NewLaunchedPlugin(const std::shared_ptr<NRIPlugin> &plugin) -> bool
+{
+    // 1. create socket for plugin
+    if (!plugin->CreateSocketPair()) {
+        ERROR("Failed to create socket pair");
+        return false;
+    }
+
+    std::string name = plugin->GetQualifiedName();
+    std::string cmd = m_pluginPath + "/" + name;
+
+    DEBUG("Plugin %s start", cmd.c_str());
+
+    // 2. exec plugin
+    nri_plugin_exec_args_t p_args = {
+        .workdir = m_pluginPath.c_str(),
+        .cmd = cmd.c_str(),
+        .name = name.c_str(),
+        .index = plugin->GetIndex().c_str(),
+        .sockFd = plugin->GetPeerSockFd(),
+    };
+
+    int pid = fork();
+    if (pid == (pid_t) -1) {
+        SYSERROR("Failed to fork");
+        return false;
+    }
+
+    if (pid == (pid_t)0) {
+        set_child_process_pdeathsig();
+
+        plugin_exec_func(&p_args);
+    }
+
+    close(plugin->GetPeerSockFd());
+
+    plugin->SetPid(pid);
+
+    return true;
+}
+
+// find plugin and create plugin
+auto NRIAdaptation::DiscoverPlugins(std::map<std::string, std::shared_ptr<NRIPlugin>> &map) -> bool
+{
+    int nret = 0;
+
+    // 1. get all plugin
+    nret = util_scan_subdirs(m_pluginPath.c_str(), walk_plugin_dir_cb, static_cast<void*>(&map));
+    if (nret != 0) {
+        ERROR("Failed to scan nri plugin subdirs");
+    }
+    return true;
+}
+
+auto NRIAdaptation::SortPlugins() -> bool
+{
+    RemoveClosedPlugins();
+
+    std::vector<std::pair<std::string, std::shared_ptr<NRIPlugin>>> sortedPlugins(m_storeMap.begin(), m_storeMap.end());
+
+    std::sort(sortedPlugins.begin(), sortedPlugins.end(), [](const auto & a, const auto & b) {
+        return a.first < b.first;
+    });
+
+    WriteGuard<RWMutex> lock(m_mutex);
+    m_storeMap.clear();
+    for (const auto &pair : sortedPlugins) {
+        m_storeMap.insert(pair);
+    }
+
+    return true;
+}
+
+auto NRIAdaptation::GetNRIPluginConfigPath(void) -> std::string
+{
+    __isula_auto_free char *config_path = nullptr;
+    std::string ret;
+
+    config_path = conf_get_nri_plugin_config_path();
+    if (config_path == nullptr) {
+        return ret;
+    }
+    ret = std::string(config_path);
+    return ret;
+}
+
+auto NRIAdaptation::GetNRIPluginPath(void) -> std::string
+{
+    __isula_auto_free char *plugin_path = nullptr;
+    std::string ret;
+
+    plugin_path = conf_get_nri_plugin_path();
+    if (plugin_path == nullptr) {
+        return ret;
+    }
+    ret = std::string(plugin_path);
+    return ret;
+}
+
+auto NRIAdaptation::GetNRISockPath(void) -> std::string
+{
+    __isula_auto_free char *sock_path = nullptr;
+    std::string ret;
+
+    sock_path = conf_get_socket_path();
+    if (sock_path == nullptr) {
+        return ret;
+    }
+    ret = std::string(sock_path);
+    return ret;
+}
+
+auto NRIAdaptation::NRIPodSandbox(const std::shared_ptr<const sandbox::Sandbox> &sandbox,
+                                  Errors &error) -> std::unique_ptr<CStructWrapper<nri_pod_sandbox>>
+{
+    auto pod = makeUniquePtrCStructWrapper<nri_pod_sandbox>(free_nri_pod_sandbox);
+    if (pod == nullptr) {
+        ERROR("Out of memory");
+        return nullptr;
+    }
+
+    if (!PodSandboxToNRI(sandbox, *pod->get())) {
+        error.Errorf("Failed to covert podsandbox to nri: %s", sandbox->GetId().c_str());
+        ERROR("Failed to covert podsandbox to nri: %s", sandbox->GetId().c_str());
+        return nullptr;
+    }
+
+    return pod;
+}
+
+auto NRIAdaptation::NRIContainerByID(const std::string &id,
+                                     Errors &error) -> std::unique_ptr<CStructWrapper<nri_container>>
+{
+    auto con = makeUniquePtrCStructWrapper<nri_container>(free_nri_container);
+    if (con == nullptr) {
+        ERROR("Out of memory");
+        return nullptr;
+    }
+
+    if (!ContainerToNRIByID(id, *con->get())) {
+        error.Errorf("Failed to covert container to nri: %s", id.c_str());
+        ERROR("Failed to covert container to nri: %s", id.c_str());
+        return nullptr;
+    }
+
+    return con;
+}
+
+auto NRIAdaptation::NRIContainerByConConfig(const std::shared_ptr<const sandbox::Sandbox> &sandbox,
+                                            const runtime::v1::ContainerConfig &containerConfig, Errors &error) -> std::unique_ptr<CStructWrapper<nri_container>>
+{
+    auto con = makeUniquePtrCStructWrapper<nri_container>(free_nri_container);
+    if (con == nullptr) {
+        ERROR("Out of memory");
+        return nullptr;
+    }
+
+    if (!ContainerToNRIByConConfig(containerConfig, *con->get())) {
+        error.Errorf("Failed to covert container to nri: %s", con->get()->name);
+        ERROR("Failed to covert container to nri: %s", con->get()->name);
+        return nullptr;
+    }
+    con->get()->pod_sandbox_id = isula_strdup_s(sandbox->GetId().c_str());
+
+    return con;
+}
\ No newline at end of file
diff --git a/src/daemon/nri/nri_adaption.h b/src/daemon/nri/nri_adaption.h
index 874662cf..27a6d93e 100644
--- a/src/daemon/nri/nri_adaption.h
+++ b/src/daemon/nri/nri_adaption.h
@@ -46,10 +46,6 @@ public:
 
     auto GetSockpath(std::vector<std::string> &paths) -> bool;
 
-    auto StopPlugins() -> bool;
-
-    void RemoveClosedPlugins();
-
     auto GetPluginByIndex(const std::string &index) -> std::shared_ptr<NRIPlugin>;
     void AddPluginByIndex(const std::string &index, std::shared_ptr<NRIPlugin> plugin);
     void RemovePluginByIndex(const std::string &index);
@@ -65,7 +61,8 @@ public:
                              Errors &error) -> bool;
     auto StartContainer(const std::string &conId, Errors &error) -> bool;
     auto PostStartContainer(const std::string &conId, Errors &error) -> bool;
-    auto UpdateContainer(const std::string &conId, Errors &error) -> bool;
+    auto UpdateContainer(const std::string &conId, const runtime::v1::LinuxContainerResources &resources,
+                         runtime::v1::LinuxContainerResources &adjust, Errors &error) -> bool;
     auto PostUpdateContainer(const std::string &conId, Errors &error) -> bool;
     auto StopContainer(const std::string &conId, Errors &error) -> bool;
     auto RemoveContainer(const std::string &conId, Errors &error) -> bool;
@@ -87,6 +84,8 @@ private:
     auto SyncPlugin() -> bool;
 
     auto SortPlugins() -> bool;
+    void RemoveClosedPlugins();
+
     void GetClosedPlugins(std::vector<std::string> &closedPlugin);
 
     auto ApplyUpdates(const std::vector<nri_container_update *> &update, std::vector<nri_container_update *> &failed,
@@ -107,18 +106,16 @@ private:
     void PluginsStateChange(nri_state_change_event *evt);
     bool PluginsCreateContainer(nri_create_container_request *req, const std::string &conId, pluginResult &result);
     bool PluginsUpdateContainer(nri_update_container_request *req, const std::string &conId, pluginResult &result);
+    bool PluginsStopContainer(nri_stop_container_request *req, const std::string &conId, pluginResult &result);
 
 private:
     RWMutex m_mutex;
     static std::atomic<NRIAdaptation *> m_instance;
     bool m_support;
     bool m_external_support;
-    std::string m_version;
     std::string m_sock_path;
     std::string m_pluginConfigPath;
     std::string m_pluginPath;
-    std::vector<std::string> m_socketPathArr;
-    std::string m_disableConnections;
     // id --> NRIPlugin map
     std::map<std::string, std::shared_ptr<NRIPlugin>> m_storeMap;
     // TODO:plugin monitor thread id??
diff --git a/src/daemon/nri/nri_helpers.cc b/src/daemon/nri/nri_helpers.cc
index ff9d67c1..b660e7a7 100644
--- a/src/daemon/nri/nri_helpers.cc
+++ b/src/daemon/nri/nri_helpers.cc
@@ -90,4 +90,25 @@ bool CheckPluginIndex(const std::string &idx)
 
     return true;
 }
+
+void FreeNriContainerUpdateVector(std::vector<nri_container_update *> &vec)
+{
+    for (auto ptr : vec) {
+        free_nri_container_update(ptr);
+    }
+}
+
+void FreeNriContainerVector(std::vector<nri_container *> &vec)
+{
+    for (auto ptr : vec) {
+        free_nri_container(ptr);
+    }
+}
+
+void FreeNriPodVector(std::vector<nri_pod_sandbox *> &vec)
+{
+    for (auto ptr : vec) {
+        free_nri_pod_sandbox(ptr);
+    }
+}
 }// namespace NRIHelpers
\ No newline at end of file
diff --git a/src/daemon/nri/nri_helpers.h b/src/daemon/nri/nri_helpers.h
index 1a2f488e..e776987b 100644
--- a/src/daemon/nri/nri_helpers.h
+++ b/src/daemon/nri/nri_helpers.h
@@ -41,6 +41,10 @@ void GenerateRandomExternalName(std::string &ret);
 
 bool CheckPluginIndex(const std::string &idx);
 
+void FreeNriContainerUpdateVector(std::vector<nri_container_update *> &vec);
+void FreeNriContainerVector(std::vector<nri_container *> &vec);
+void FreeNriPodVector(std::vector<nri_pod_sandbox *> &vec);
+
 template <typename T>
 void freeArray(T ** &arr, int size)
 {
diff --git a/src/daemon/nri/nri_plugin_ops.cc b/src/daemon/nri/nri_plugin_ops.cc
new file mode 100644
index 00000000..e2f88b63
--- /dev/null
+++ b/src/daemon/nri/nri_plugin_ops.cc
@@ -0,0 +1,123 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2024. All rights reserved.
+ * iSulad licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *     http://license.coscl.org.cn/MulanPSL2
+ * 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 v2 for more details.
+ * Author: zhongtao
+ * Create: 2024-03-26
+ * Description: provide nri plugin api definition
+ ******************************************************************************/
+#include "nri_plugin_ops.h"
+
+#include <isula_libutils/log.h>
+#include <isula_libutils/auto_cleanup.h>
+
+#include "nri_adaption.h"
+#include "nri_plugin.h"
+#include "isulad_config.h"
+
+static bool start_external_listener()
+{
+    __isula_auto_free char *sock_path = NULL;
+
+    sock_path = conf_get_socket_path();
+    if (sock_path == NULL) {
+        ERROR("Failed to get socket path");
+        return false;
+    }
+
+    if (nri_external_service_start(sock_path, nri_external_plugin_connect) != 0) {
+        ERROR("Failed to lauch external service");
+        return false;
+    }
+    return true;
+}
+
+bool nri_adaption_init(void)
+{
+    Errors error;
+
+    if (!conf_get_nri_support()) {
+        return true;
+    }
+
+    nri_runtime_callbacks callbacks;
+    callbacks.register_plugin = nri_registry_containers;
+    callbacks.update_containers =  nri_update_containers;
+    if (nri_runtime_service_init(callbacks) != 0) {
+        ERROR("Failed to init runtime service\n");
+        return false;
+    }
+
+    if (conf_get_nri_external_support()) {
+        if (!start_external_listener()) {
+            ERROR("Failed to start external listener\n");
+            goto clean_out;
+        }
+    }
+
+    NRIAdaptation::GetInstance()->Init(error);
+    if (error.NotEmpty()) {
+        ERROR("Failed to init NRIAdaptation: %s", error.GetCMessage());
+        goto clean_out;
+    }
+    return true;
+clean_out:
+    nri_runtime_service_destroy();
+    return false;
+}
+
+bool nri_adaption_shutdown(void)
+{
+    nri_external_service_shutdown();
+    nri_runtime_service_destroy();
+    return true;
+}
+
+int nri_update_containers(const char *plugin_id, const nri_update_containers_request *request,
+                          nri_update_containers_response **response)
+{
+    if (request == nullptr || response == nullptr || plugin_id == nullptr) {
+        ERROR("Invalid input arguments");
+        return -1;
+    }
+
+    if (!NRIAdaptation::GetInstance()->updateContainers(request, response)) {
+        ERROR("Failed to update containers by plugin %s", plugin_id);
+        return -1;
+    }
+
+    return 0;
+}
+
+int nri_registry_containers(const char *plugin_id, const nri_register_plugin_request *request)
+{
+    if (request == nullptr || plugin_id == nullptr) {
+        ERROR("Invalid input arguments");
+        return -1;
+    }
+
+    auto plugin = NRIAdaptation::GetInstance()->GetPluginByIndex(plugin_id);
+    if (plugin == nullptr) {
+        ERROR("Failed to get plugin by index %s", plugin_id);
+        return -1;
+    }
+
+    plugin->SetReady();
+    return 0;
+}
+
+int nri_external_plugin_connect(int fd)
+{
+    if (fd < 0) {
+        ERROR("Invalid input arguments");
+        return -1;
+    }
+
+    return NRIAdaptation::GetInstance()->NewExternalPlugin(fd) ? 0 : -1;
+}
\ No newline at end of file
diff --git a/src/daemon/nri/nri_plugin_ops.h b/src/daemon/nri/nri_plugin_ops.h
index 37d437d2..3a5393ba 100644
--- a/src/daemon/nri/nri_plugin_ops.h
+++ b/src/daemon/nri/nri_plugin_ops.h
@@ -25,13 +25,15 @@ extern "C" {
 #endif
 
 bool nri_adaption_init(void);
+bool nri_adaption_shutdown(void);
 
 #ifdef __cplusplus
 }
 #endif
 
-int nri_update_containers(const nri_update_containers_request *request, nri_update_containers_response **response);
-int nri_registry_containers(const nri_register_plugin_request *request);
+int nri_update_containers(const char *plugin_id, const nri_update_containers_request *request,
+                          nri_update_containers_response **response);
+int nri_registry_containers(const char *plugin_id, const nri_register_plugin_request *request);
 
 int nri_external_plugin_connect(int fd);
 
diff --git a/src/daemon/nri/nri_result.cc b/src/daemon/nri/nri_result.cc
new file mode 100644
index 00000000..7da4451d
--- /dev/null
+++ b/src/daemon/nri/nri_result.cc
@@ -0,0 +1,977 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2024. All rights reserved.
+ * iSulad licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *     http://license.coscl.org.cn/MulanPSL2
+ * 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 v2 for more details.
+ * Author: zhongtao
+ * Create: 2024-06-29
+ * Description: provide nri result definition
+ *********************************************************************************/
+
+#include "nri_result.h"
+
+#include <isula_libutils/log.h>
+#include <isula_libutils/nri_container_adjustment.h>
+
+#include "cxxutils.h"
+#include "transform.h"
+#include "utils.h"
+
+pluginResult::~pluginResult()
+{
+    free_nri_linux_resources(m_update_req);
+    free_nri_container_adjustment(m_reply.adjust);
+    for (size_t i = 0; i < m_reply.update.size(); i++) {
+        free_nri_container_update(m_reply.update[i]);
+    }
+}
+
+auto pluginResult::InitReply() -> bool
+{
+    m_reply.adjust = (nri_container_adjustment *)util_common_calloc_s(sizeof(nri_container_adjustment));
+    if (m_reply.adjust == NULL) {
+        ERROR("Out of memory");
+        return false;
+    }
+    return true;
+}
+
+auto pluginResult::Init() -> bool
+{
+    if (!InitReply()) {
+        ERROR("Failed to init reply");
+        return false;
+    }
+    m_update_req = nullptr;
+    return true;
+}
+
+auto pluginResult::InitByConId(std::string conId) -> bool
+{
+    m_conId = conId;
+
+    if (!InitReply()) {
+        ERROR("Failed to init reply");
+        return false;
+    }
+
+    m_update_req = nullptr;
+    return true;
+}
+
+auto pluginResult::InitByUpdateReq(nri_update_container_request *req) -> bool
+{
+    m_conId = req->container->id;
+    m_update_req = copy_nri_linux_resources(req->linux_resources);
+    if (m_update_req == nullptr) {
+        ERROR("Failed to copy nri linux resources");
+        return false;
+    }
+
+    if (!InitReply()) {
+        ERROR("Failed to init reply");
+        return false;
+    }
+    m_update_req = nullptr;
+    return true;
+}
+
+auto pluginResult::GetReplyUpdate() -> std::vector<nri_container_update*>
+{
+    return m_reply.update;
+}
+
+auto pluginResult::MoveReplyAdjust() -> nri_container_adjustment *
+{
+    nri_container_adjustment *ret = m_reply.adjust;
+    m_reply.adjust = nullptr;
+    return ret;
+}
+
+auto pluginResult::GetReplyResources(const std::string &id) -> const nri_linux_resources *
+{
+    nri_linux_resources *ret = NULL;
+    nri_container_update *update = m_updates[id];
+    ret = update->linux->resources;
+    return ret;
+}
+
+auto pluginResult::Apply(int32_t event, const nri_container_adjustment *adjust, nri_container_update **update,
+                         size_t update_len, const std::string &plugin) -> bool
+{
+    if (plugin.length() == 0) {
+        ERROR("Empty plugin name");
+        return false;
+    }
+    if (event == CREATE_CONTAINER) {
+        if (!Adjust(adjust, plugin)) {
+            ERROR("Failed to do adjust to plugin: %s", plugin.c_str());
+            return false;
+        }
+
+        if (!Update(update, update_len, plugin)) {
+            ERROR("Failed to do update to plugin: %s", plugin.c_str());
+            return false;
+        }
+        return true;
+    } else if (event == UPDATE_CONTAINER) {
+        if (!Update(update, update_len, plugin)) {
+            ERROR("Failed to do update to plugin: %s", plugin.c_str());
+            return false;
+        }
+        return true;
+    } else if (event == STOP_CONTAINER) {
+        if (!Update(update, update_len, plugin)) {
+            ERROR("Failed to do update to plugin: %s", plugin.c_str());
+            return false;
+        }
+        return true;
+    } else {
+        ERROR("Cannot apply response of invalid type %d", event);
+        return false;
+    }
+    return true;
+}
+
+auto pluginResult::Adjust(const nri_container_adjustment *adjust, const std::string &plugin) -> bool
+{
+    if (adjust == nullptr) {
+        return true;
+    }
+
+    if (!AdjustAnnotations(adjust->annotations, plugin)) {
+        ERROR("Cannot adajust annotations by plugin %s", plugin.c_str());
+        return false;
+    }
+
+    if (!AdjustMounts(adjust->mounts, adjust->mounts_len, plugin)) {
+        ERROR("Cannot adajust mounts by plugin %s", plugin.c_str());
+        return false;
+    }
+
+    if (!AdjustEnv(adjust->env, adjust->env_len, plugin)) {
+        ERROR("Cannot adajust mounts by plugin %s", plugin.c_str());
+        return false;
+    }
+
+    if (!AdjustHooks(adjust->hooks, plugin)) {
+        ERROR("Cannot adajust hooks by plugin %s", plugin.c_str());
+        return false;
+    }
+
+    if (adjust->linux != nullptr) {
+        if (m_reply.adjust->linux == nullptr) {
+            m_reply.adjust->linux = (nri_linux_container_adjustment *)util_common_calloc_s(sizeof(nri_linux_container_adjustment));
+            if (m_reply.adjust->linux == nullptr) {
+                ERROR("Out of memory");
+                return false;
+            }
+        }
+
+        if (!AdjustDevices(adjust->linux->devices, adjust->linux->devices_len, plugin)) {
+            ERROR("Cannot adajust devices by plugin %s", plugin.c_str());
+            return false;
+        }
+
+        if (!AdjustResources(adjust->linux->resources, plugin)) {
+            ERROR("Cannot adajust devices by plugin %s", plugin.c_str());
+            return false;
+        }
+
+        if (!AdjustCgroupsPath(adjust->linux->cgroups_path, plugin)) {
+            ERROR("Cannot adajust cgroups path by plugin %s", plugin.c_str());
+            return false;
+        }
+    }
+
+    if (!AdjustRlimits(adjust->rlimits, adjust->rlimits_len, plugin)) {
+        ERROR("Cannot adajust rlimits path by plugin %s", plugin.c_str());
+        return false;
+    }
+
+    return true;
+}
+
+auto pluginResult::AdjustAnnotations(json_map_string_string *annos, const std::string &plugin) -> bool
+{
+    if (annos == nullptr || annos->len == 0) {
+        return true;
+    }
+
+    if (m_reply.adjust->annotations == nullptr) {
+        m_reply.adjust->annotations = (json_map_string_string *)util_common_calloc_s(sizeof(json_map_string_string));
+        if (m_reply.adjust->annotations == nullptr) {
+            ERROR("Out of memory");
+            return false;
+        }
+    }
+
+    google::protobuf::Map<std::string, std::string> del;
+    const char *id = m_conId.c_str();
+    google::protobuf::Map<std::string, std::string> mapAnno;
+    Transform::JsonMapToProtobufMapForString(annos, mapAnno);
+
+    // if key is marked for remove, add pair to del, and delete key from annos
+    for (auto it = mapAnno.begin(); it != mapAnno.end();) {
+        const std::string &key = it->first;
+        char *out = NULL;
+        if (is_marked_for_removal(key.c_str(), &out)) {
+            del[out] = "";
+            it = mapAnno.erase(it);
+        } else {
+            ++it;
+        }
+    }
+
+    for (const auto &iter : mapAnno) {
+        std::string key = iter.first;
+        std::string value = iter.second;
+        auto it = del.find(key);
+        if (it != del.end()) {
+            auto owner = m_owners.find(id);
+            if (owner != m_owners.end()) {
+                m_owners[id].annotations.erase(key);
+            }
+            append_json_map_string_string(m_reply.adjust->annotations, NRIHelpers::MarkForRemoval(key).c_str(), "");
+        }
+
+        // set annotations's owner plugin
+        auto owner = m_owners.find(id);
+        if (owner != m_owners.end()) {
+            auto anno = m_owners[id].annotations.find(key);
+            if (anno != m_owners[id].annotations.end()) {
+                ERROR("plugins %s and %s both tried to set annotation: %s", plugin.c_str(), anno->second.c_str(), key.c_str());
+                return false;
+            }
+            m_owners[id].annotations[key] = plugin;
+        }
+
+        // add pair to m_reply.adjust
+        append_json_map_string_string(m_reply.adjust->annotations, key.c_str(), value.c_str());
+        del.erase(key);
+    }
+
+    // add del to m_reply.adjust
+    for (auto &pair : del) {
+        append_json_map_string_string(m_reply.adjust->annotations, NRIHelpers::MarkForRemoval(pair.first).c_str(), "");
+    }
+
+    return true;
+}
+
+auto pluginResult::AdjustMounts(nri_mount **mounts, size_t mounts_size, const std::string &plugin) -> bool
+{
+    if (mounts == nullptr || mounts_size == 0) {
+        return true;
+    }
+
+    size_t i;
+    std::vector<nri_mount *> add;
+    std::map<std::string, nri_mount *> del;
+    std::string id = m_conId.c_str();
+
+    // first split removals from the rest of adjustments
+    for (i = 0; i < mounts_size; i++) {
+        char *out = NULL;
+        if (is_marked_for_removal(mounts[i]->destination, &out)) {
+            del[out] = mounts[i];
+        } else {
+            add.push_back(mounts[i]);
+        }
+    }
+
+    // next remove marked mounts from collected adjustments
+    nri_mount** cleard = nullptr;
+    size_t clearLen = 0;
+
+    if (m_reply.adjust->mounts_len > 0) {
+        cleard = (nri_mount **)util_common_calloc_s(m_reply.adjust->mounts_len * sizeof(nri_mount *));
+        if (cleard == nullptr) {
+            ERROR("Out of memory");
+            return false;
+        }
+
+        for (i = 0; i < m_reply.adjust->mounts_len; i++) {
+            auto removed = del.find(m_reply.adjust->mounts[i]->destination);
+            if (removed != del.end()) {
+                auto owner = m_owners.find(id);
+                if (owner != m_owners.end()) {
+                    m_owners[id].mounts.erase(m_reply.adjust->mounts[i]->destination);
+                }
+                continue;
+            }
+            cleard[clearLen] = copy_nri_mount(m_reply.adjust->mounts[i]);
+            if (cleard[clearLen] == nullptr) {
+                ERROR("Failed to copy nri mounts to cleard");
+                return false;
+            }
+            clearLen++;
+        }
+
+        NRIHelpers::freeArray(m_reply.adjust->mounts, m_reply.adjust->mounts_len);
+        m_reply.adjust->mounts = cleard;
+        m_reply.adjust->mounts_len = clearLen;   
+    }
+
+    // finally, apply additions to collected adjustments
+    size_t oldSize, newSize;
+    oldSize = m_reply.adjust->mounts_len * sizeof(nri_mount *);
+    newSize = oldSize + add.size() * sizeof(nri_mount *);
+    int ret = util_mem_realloc((void **)(&m_reply.adjust->mounts), newSize, (void *)m_reply.adjust->mounts, oldSize);
+    if (ret != 0) {
+        ERROR("Failed to realloc and assign nri mounts array");
+        return false;
+    }
+    for (i = 0; i < add.size(); i++) {
+        // set mounts's owner plugin
+        auto owner = m_owners.find(id);
+        if (owner != m_owners.end()) {
+            auto mount = m_owners[id].mounts.find(add[i]->destination);
+            if (mount != m_owners[id].mounts.end()) {
+                ERROR("plugins %s and %s both tried to set mount: %s", plugin.c_str(), mount->second.c_str(), add[i]->destination);
+                return false;
+            }
+            m_owners[id].mounts[add[i]->destination] = plugin;
+        }
+        m_reply.adjust->mounts[m_reply.adjust->mounts_len] = copy_nri_mount(add[i]);
+        if (m_reply.adjust->mounts[m_reply.adjust->mounts_len] == nullptr) {
+            ERROR("Failed to copy add nri mounts to reply adjust");
+            return false;
+        }
+        m_reply.adjust->mounts_len++;
+    }
+
+    return true;
+}
+
+auto pluginResult::AdjustEnv(nri_key_value **envs, size_t envs_size, const std::string &plugin) -> bool
+{
+    if (envs == nullptr || envs_size == 0) {
+        return true;
+    }
+
+    size_t i;
+    std::vector<nri_key_value *> add;
+    std::map<std::string, nri_key_value *> del;
+    std::string id = m_conId.c_str();
+
+    // first split removals from the rest of adjustments
+    for (i = 0; i < envs_size; i++) {
+        char *out = NULL;
+        if (is_marked_for_removal(envs[i]->key, &out)) {
+            del[out] = envs[i];
+        } else {
+            add.push_back(envs[i]);
+        }
+    }
+
+    // next remove marked mounts from collected adjustments
+    nri_key_value** cleard;
+    size_t clearLen = 0;
+
+    if(m_reply.adjust->env_len > 0) {
+        cleard = (nri_key_value **)util_common_calloc_s(m_reply.adjust->env_len * sizeof(nri_key_value *));
+        if (cleard == nullptr) {
+            ERROR("Out of memory");
+            return false;
+        }
+
+        for (i = 0; i < m_reply.adjust->env_len; i++) {
+            auto removed = del.find(m_reply.adjust->env[i]->key);
+            if (removed != del.end()) {
+                auto owner = m_owners.find(id);
+                if (owner != m_owners.end()) {
+                    m_owners[id].env.erase(m_reply.adjust->env[i]->key);
+                }
+                continue;
+            }
+            cleard[clearLen] = copy_nri_key_value(m_reply.adjust->env[i]);
+            if (cleard[clearLen] == nullptr) {
+                ERROR("Failed to copy nri env key value to cleard");
+                return false;
+            }
+            clearLen++;
+        }
+
+        NRIHelpers::freeArray(m_reply.adjust->env, m_reply.adjust->env_len);
+        m_reply.adjust->env = cleard;
+        m_reply.adjust->env_len = clearLen;
+    }
+
+    // finally, apply additions to collected adjustments
+    size_t oldSize, newSize;
+    oldSize = m_reply.adjust->env_len * sizeof(nri_key_value *);
+    newSize = oldSize + add.size() * sizeof(nri_key_value *);
+    int ret = util_mem_realloc((void **)(&m_reply.adjust->env), newSize, m_reply.adjust->env, oldSize);
+    if (ret != 0) {
+        ERROR("Failed to realloc and assign nri env array");
+        return false;
+    }
+    for (i = 0; i < add.size(); i++) {
+        // set env's owner plugin
+        auto owner = m_owners.find(id);
+        if (owner != m_owners.end()) {
+            auto env = m_owners[id].env.find(add[i]->key);
+            if (env != m_owners[id].env.end()) {
+                ERROR("plugins %s and %s both tried to set env: %s", plugin.c_str(), env->second.c_str(), add[i]->key);
+                return false;
+            }
+            m_owners[id].env[add[i]->key] = plugin;
+        }
+        m_reply.adjust->env[m_reply.adjust->env_len] = copy_nri_key_value(add[i]);
+        if (m_reply.adjust->env[m_reply.adjust->env_len] == nullptr) {
+            ERROR("Failed to copy add nri env to reply adjust");
+            return false;
+        }
+        m_reply.adjust->env_len++;
+    }
+
+    return true;
+}
+
+auto pluginResult::AdjustHooks(const nri_hooks *hooks, const std::string &plugin) -> bool
+{
+    if (hooks == nullptr) {
+        return true;
+    }
+
+    if (m_reply.adjust->hooks == nullptr) {
+        m_reply.adjust->hooks = (nri_hooks *)util_common_calloc_s(sizeof(nri_hooks));
+        if (m_reply.adjust->hooks == nullptr) {
+            ERROR("Out of memory");
+            return false;
+        }
+    }
+
+    nri_hooks * reply = m_reply.adjust->hooks;
+
+    if (!merge_nri_hooks(reply->prestart, reply->prestart_len, (const nri_hook**)hooks->prestart, hooks->prestart_len)) {
+        ERROR("Failed to realloc and copy prestart hooks");
+        return false;
+    }
+
+    if (!merge_nri_hooks(reply->poststart, reply->poststart_len, (const nri_hook**)hooks->poststart,
+                         hooks->poststart_len)) {
+        ERROR("Failed to realloc and copy poststart hooks");
+        return false;
+    }
+
+    if (!merge_nri_hooks(reply->poststop, reply->poststop_len, (const nri_hook**)hooks->poststop, hooks->poststop_len)) {
+        ERROR("Failed to realloc and copy poststop hooks");
+        return false;
+    }
+
+    /* TODO:zhongtao
+    * The OCI being used by the iSulad not supportes
+    * createRuntime/createContainer/startContainer currently.
+    */
+    if (!merge_nri_hooks(reply->create_runtime, reply->create_runtime_len, (const nri_hook**)hooks->create_runtime,
+                         hooks->create_runtime_len)) {
+        ERROR("Failed to realloc and copy create_runtime hooks");
+        return false;
+    }
+
+    if (!merge_nri_hooks(reply->create_container, reply->create_container_len, (const nri_hook**)hooks->create_container,
+                         hooks->create_container_len)) {
+        ERROR("Failed to realloc and copy create_container hooks");
+        return false;
+    }
+
+    if (!merge_nri_hooks(reply->start_container, reply->start_container_len, (const nri_hook**)hooks->start_container,
+                         hooks->start_container_len)) {
+        ERROR("Failed to realloc and copy start_container hooks");
+        return false;
+    }
+
+    return false;
+}
+
+auto pluginResult::AdjustDevices(nri_linux_device **devices, size_t devices_size, const std::string &plugin) -> bool
+{
+    if (devices_size == 0) {
+        return true;
+    }
+
+    size_t i;
+    std::vector<nri_linux_device *> add;
+    std::map<std::string, nri_linux_device *> del;
+    std::string id = m_conId.c_str();
+
+    // first split removals from the rest of adjustments
+    for (i = 0; i < devices_size; i++) {
+        char *out = NULL;
+        if (is_marked_for_removal(devices[i]->path, &out)) {
+            del[out] = devices[i];
+        } else {
+            add.push_back(devices[i]);
+        }
+    }
+
+    // next remove marked mounts from collected adjustments
+    nri_linux_device** cleard;
+    size_t clearLen = 0;
+
+    if (m_reply.adjust->linux->devices_len > 0) {
+        cleard = (nri_linux_device **)util_common_calloc_s(m_reply.adjust->linux->devices_len * sizeof(nri_linux_device *));
+        if (cleard == nullptr) {
+            ERROR("Out of memory");
+            return false;
+        }
+        for (i = 0; i < m_reply.adjust->linux->devices_len; i++) {
+            auto removed = del.find(m_reply.adjust->linux->devices[i]->path);
+            if (removed != del.end()) {
+                auto owner = m_owners.find(id);
+                if (owner != m_owners.end()) {
+                    m_owners[id].devices.erase(m_reply.adjust->linux->devices[i]->path);
+                }
+                continue;
+            }
+            cleard[clearLen] = copy_nri_device(m_reply.adjust->linux->devices[i]);
+            if (cleard[clearLen] == nullptr) {
+                ERROR("Failed to copy nri linux device to cleard");
+                return false;
+            }
+            clearLen++;
+        }
+
+        NRIHelpers::freeArray(m_reply.adjust->linux->devices, m_reply.adjust->linux->devices_len);
+        m_reply.adjust->linux->devices = cleard;
+        m_reply.adjust->linux->devices_len = clearLen;
+    }
+
+    // finally, apply additions to collected adjustments
+    size_t oldSize, newSize;
+    oldSize = m_reply.adjust->linux->devices_len * sizeof(nri_linux_device *);
+    newSize = oldSize + add.size() * sizeof(nri_linux_device *);
+    int ret = util_mem_realloc((void **)(&m_reply.adjust->linux->devices), newSize, m_reply.adjust->linux->devices, oldSize);
+    if (ret != 0) {
+        ERROR("Failed to realloc and assign nri devices array");
+        return false;
+    }
+    for (i = 0; i < add.size(); i++) {
+        // set mounts's owner plugin
+        auto owner = m_owners.find(id);
+        if (owner != m_owners.end()) {
+            auto device = m_owners[id].devices.find(add[i]->path);
+            if (device != m_owners[id].devices.end()) {
+                ERROR("plugins %s and %s both tried to set devices: %s", plugin.c_str(), device->second.c_str(), add[i]->path);
+                return false;
+            }
+            m_owners[id].devices[add[i]->path] = plugin;
+        }
+        m_reply.adjust->linux->devices[m_reply.adjust->linux->devices_len] = copy_nri_device(add[i]);
+        if (m_reply.adjust->linux->devices[m_reply.adjust->linux->devices_len] == nullptr) {
+            ERROR("Failed to copy add nri devices to reply adjust");
+            return false;
+        }
+        m_reply.adjust->linux->devices_len++;
+    }
+
+    return true;
+}
+
+auto pluginResult::AdjustResources(nri_linux_resources *resources, const std::string &plugin) -> bool
+{
+    if (resources == nullptr) {
+        return true;
+    }
+
+    if (m_reply.adjust->linux->resources == nullptr) {
+        m_reply.adjust->linux->resources = (nri_linux_resources *)util_common_calloc_s(sizeof(nri_linux_resources));
+        if (m_reply.adjust->linux->resources == nullptr) {
+            ERROR("Out of memory");
+            return false;
+        }
+    }
+
+    std::string id = m_conId.c_str();
+    nri_linux_resources *reply = m_reply.adjust->linux->resources;
+
+    return ClaimAndCopyResources(resources, id, plugin, reply);
+}
+
+bool pluginResult::ClaimAndCopyResources(nri_linux_resources *src, std::string &id, const std::string &plugin,
+                                         nri_linux_resources *dest)
+{
+    size_t i;
+    if (src->memory != nullptr) {
+        if (src->memory->limit != nullptr) {
+            auto memLimit = m_owners[id].memLimit;
+            if (!memLimit.empty()) {
+                ERROR("plugins %s and %s both tried to set devices's memory limit", plugin.c_str(), memLimit.c_str());
+                return false;
+            }
+            m_owners[id].memLimit = plugin;
+            *dest->memory->limit = *src->memory->limit;
+        }
+
+        if (src->memory->reservation != nullptr) {
+            auto memReservation = m_owners[id].memReservation;
+            if (!memReservation.empty()) {
+                ERROR("plugins %s and %s both tried to set devices's memory reservation", plugin.c_str(),
+                      memReservation.c_str());
+                return false;
+            }
+            m_owners[id].memReservation = plugin;
+            *dest->memory->reservation = *src->memory->reservation;
+        }
+
+        if (src->memory->swap != nullptr) {
+            auto memSwapLimit = m_owners[id].memSwapLimit;
+            if (!memSwapLimit.empty()) {
+                ERROR("plugins %s and %s both tried to set devices's memory swap limit", plugin.c_str(),
+                      memSwapLimit.c_str());
+                return false;
+            }
+            m_owners[id].memSwapLimit = plugin;
+            *dest->memory->swap = *src->memory->swap;
+        }
+
+        if (src->memory->kernel != nullptr) {
+            auto memKernelLimit = m_owners[id].memKernelLimit;
+            if (!memKernelLimit.empty()) {
+                ERROR("plugins %s and %s both tried to set devices's memory kernel limit", plugin.c_str(),
+                      memKernelLimit.c_str());
+                return false;
+            }
+            m_owners[id].memKernelLimit = plugin;
+            *dest->memory->kernel = *src->memory->kernel;
+        }
+
+        if (src->memory->kernel_tcp != nullptr) {
+            auto memTCPLimit = m_owners[id].memTCPLimit;
+            if (!memTCPLimit.empty()) {
+                ERROR("plugins %s and %s both tried to set devices's memory tcp limit", plugin.c_str(),
+                      memTCPLimit.c_str());
+                return false;
+            }
+            m_owners[id].memTCPLimit = plugin;
+            *dest->memory->kernel_tcp = *src->memory->kernel_tcp;
+        }
+
+        if (src->memory->swappiness != nullptr) {
+            auto memSwappiness = m_owners[id].memSwappiness;
+            if (!memSwappiness.empty()) {
+                ERROR("plugins %s and %s both tried to set devices's memory swappiness", plugin.c_str(),
+                      memSwappiness.c_str());
+                return false;
+            }
+            m_owners[id].memSwappiness = plugin;
+            *dest->memory->swappiness = *src->memory->swappiness;
+        }
+
+        if (src->memory->disable_oom_killer != nullptr) {
+            auto memDisableOomKiller = m_owners[id].memDisableOomKiller;
+            if (!memDisableOomKiller.empty()) {
+                ERROR("plugins %s and %s both tried to set devices's memory disable_oom_killer", plugin.c_str(),
+                      memDisableOomKiller.c_str());
+                return false;
+            }
+            m_owners[id].memDisableOomKiller = plugin;
+            *dest->memory->disable_oom_killer = *src->memory->disable_oom_killer;
+        }
+
+        if (src->memory->use_hierarchy != nullptr) {
+            auto memUseHierarchy = m_owners[id].memUseHierarchy;
+            if (!memUseHierarchy.empty()) {
+                ERROR("plugins %s and %s both tried to set devices's memory use_hierarchy", plugin.c_str(),
+                      memUseHierarchy.c_str());
+                return false;
+            }
+            m_owners[id].memUseHierarchy = plugin;
+            *dest->memory->use_hierarchy = *src->memory->use_hierarchy;
+        }
+    }
+
+    if (src->cpu != nullptr) {
+        if (src->cpu->shares != nullptr) {
+            auto cpuShares = m_owners[id].cpuShares;
+            if (!cpuShares.empty()) {
+                ERROR("plugins %s and %s both tried to set devices's cpu shares", plugin.c_str(), cpuShares.c_str());
+                return false;
+            }
+            m_owners[id].cpuShares = plugin;
+            *dest->cpu->shares = *src->cpu->shares;
+        }
+
+        if (src->cpu->quota != nullptr) {
+            auto cpuQuota = m_owners[id].cpuQuota;
+            if (!cpuQuota.empty()) {
+                ERROR("plugins %s and %s both tried to set devices's cpu quota", plugin.c_str(), cpuQuota.c_str());
+                return false;
+            }
+            m_owners[id].cpuQuota = plugin;
+            *dest->cpu->quota = *src->cpu->quota;
+        }
+
+        if (src->cpu->period != nullptr) {
+            auto cpuPeriod = m_owners[id].cpuPeriod;
+            if (!cpuPeriod.empty()) {
+                ERROR("plugins %s and %s both tried to set devices's cpu period", plugin.c_str(), cpuPeriod.c_str());
+                return false;
+            }
+            m_owners[id].cpuPeriod = plugin;
+            *dest->cpu->period = *src->cpu->period;
+        }
+
+        if (src->cpu->realtime_runtime != nullptr) {
+            auto cpuRealtimePeriod = m_owners[id].cpuRealtimePeriod;
+            if (!cpuRealtimePeriod.empty()) {
+                ERROR("plugins %s and %s both tried to set devices's cpu realtime_runtime", plugin.c_str(),
+                      cpuRealtimePeriod.c_str());
+                return false;
+            }
+            m_owners[id].cpuRealtimePeriod = plugin;
+            *dest->cpu->realtime_runtime = *src->cpu->realtime_runtime;
+        }
+
+        if (src->cpu->realtime_period != nullptr) {
+            auto cpuRealtimePeriod = m_owners[id].cpuRealtimePeriod;
+            if (!cpuRealtimePeriod.empty()) {
+                ERROR("plugins %s and %s both tried to set devices's cpu realtime_period", plugin.c_str(),
+                      cpuRealtimePeriod.c_str());
+                return false;
+            }
+            m_owners[id].cpuRealtimePeriod = plugin;
+            *dest->cpu->realtime_period = *src->cpu->realtime_period;
+        }
+
+        if (src->cpu->cpus != nullptr) {
+            auto cpusetCpus = m_owners[id].cpusetCpus;
+            if (!cpusetCpus.empty()) {
+                ERROR("plugins %s and %s both tried to set devices's cpu cpus", plugin.c_str(), cpusetCpus.c_str());
+                return false;
+            }
+            m_owners[id].cpusetCpus = plugin;
+            *dest->cpu->cpus = *src->cpu->cpus;
+        }
+
+        if (src->cpu->mems != nullptr) {
+            auto cpusetMems = m_owners[id].cpusetMems;
+            if (!cpusetMems.empty()) {
+                ERROR("plugins %s and %s both tried to set devices's cpu mems", plugin.c_str(), cpusetMems.c_str());
+                return false;
+            }
+            m_owners[id].cpusetMems = plugin;
+            *dest->cpu->mems = *src->cpu->mems;
+        }
+    }
+
+    for (i = 0; i < src->hugepage_limits_len; i++) {
+        auto owner = m_owners.find(id);
+        if (owner != m_owners.end()) {
+            auto find = m_owners[id].hugepageLimits.find(src->hugepage_limits[i]->page_size);
+            if (find != m_owners[id].hugepageLimits.end()) {
+                ERROR("plugins %s and %s both tried to set hugepageLimits: %s", plugin.c_str(), find->second.c_str(),
+                      src->hugepage_limits[i]->page_size);
+                return false;
+            }
+            m_owners[id].hugepageLimits[src->hugepage_limits[i]->page_size] = plugin;
+        }
+    }
+
+    if (src->unified->len != 0) {
+        google::protobuf::Map<std::string, std::string> mapAnno;
+        Transform::JsonMapToProtobufMapForString(src->unified, mapAnno);
+        for (const auto &iter : mapAnno) {
+            std::string key = iter.first;
+            std::string value = iter.second;
+            auto owner = m_owners.find(id);
+            if (owner != m_owners.end()) {
+                auto anno = m_owners[id].unified.find(key);
+                if (anno != m_owners[id].unified.end()) {
+                    ERROR("plugins %s and %s both tried to set unified: %s", plugin.c_str(), anno->second.c_str(),
+                          key.c_str());
+                    return false;
+                }
+                m_owners[id].unified[key] = plugin;
+            }
+            // add pair to m_reply.adjust
+            append_json_map_string_string(dest->unified, key.c_str(), value.c_str());
+        }
+    }
+
+    if (src->blockio_class != nullptr) {
+        auto blockioClass = m_owners[id].blockioClass;
+        if (!blockioClass.empty()) {
+            ERROR("plugins %s and %s both tried to set devices's blockio_class", plugin.c_str(), blockioClass.c_str());
+            return false;
+        }
+        m_owners[id].blockioClass = plugin;
+        dest->blockio_class = util_strdup_s(src->blockio_class);
+    }
+
+    if (src->rdt_class != nullptr) {
+        auto rdtClass = m_owners[id].rdtClass;
+        if (!rdtClass.empty()) {
+            ERROR("plugins %s and %s both tried to set devices's rdt_class", plugin.c_str(), rdtClass.c_str());
+            return false;
+        }
+        m_owners[id].rdtClass = plugin;
+        dest->rdt_class = util_strdup_s(src->rdt_class);
+    }
+    return true;
+}
+
+auto pluginResult::AdjustCgroupsPath(char *path, const std::string &plugin) -> bool
+{
+    if (path == nullptr || strcmp(path, "") == 0) {
+        return true;
+    }
+
+    std::string id = m_conId.c_str();
+
+    auto cgroupsPath = m_owners[id].cgroupsPath;
+    if (!cgroupsPath.empty()) {
+        ERROR("plugins %s and %s both tried to set devices's cgroups path", plugin.c_str(), cgroupsPath.c_str());
+        return false;
+    }
+    m_owners[id].cgroupsPath = plugin;
+    m_reply.adjust->linux->cgroups_path = util_strdup_s(path);
+
+    return true;
+}
+
+auto pluginResult::AdjustRlimits(nri_posix_rlimit **rlimits, size_t rlimits_len, const std::string &plugin) -> bool
+{
+    if (rlimits_len == 0) {
+        return true;
+    }
+
+    size_t i;
+    std::string id = m_conId.c_str();
+
+    size_t oldSize, newSize;
+    oldSize = m_reply.adjust->rlimits_len * sizeof(nri_posix_rlimit *);
+    newSize = oldSize + rlimits_len * sizeof(nri_posix_rlimit *);
+    int ret = util_mem_realloc((void **)(&m_reply.adjust->rlimits), newSize, m_reply.adjust->rlimits, oldSize);
+    if (ret != 0) {
+        ERROR("Failed to realloc and assign nri rlimits array");
+        return false;
+    }
+
+    for (i = 0; i < rlimits_len; i++) {
+        auto owner = m_owners.find(id);
+        if (owner != m_owners.end()) {
+            auto find = m_owners[id].rlimits.find(rlimits[i]->type);
+            if (find != m_owners[id].rlimits.end()) {
+                ERROR("plugins %s and %s both tried to set rlimits type: %s", plugin.c_str(), find->second.c_str(), rlimits[i]->type);
+                return false;
+            }
+            m_owners[id].rlimits[rlimits[i]->type] = plugin;
+        }
+        m_reply.adjust->rlimits[m_reply.adjust->rlimits_len] = copy_nri_posix_rlimit(rlimits[i]);
+        if (m_reply.adjust->rlimits[m_reply.adjust->rlimits_len] == nullptr) {
+            ERROR("Failed to copy add nri rlimits to reply adjust");
+            return false;
+        }
+        m_reply.adjust->rlimits_len++;
+    }
+    return true;
+}
+
+auto pluginResult::Update(nri_container_update **updates, size_t update_len, const std::string &plugin) -> bool
+{
+    if (update_len == 0) {
+        return true;
+    }
+
+    size_t i;
+
+    for (i = 0; i < update_len; i++) {
+        nri_container_update *reply;
+        if (!GetContainerUpdate(updates[i], plugin, &reply)) {
+            ERROR("Failed to get container update in plugin result");
+            return false;
+        }
+
+        if (!UpdateResources(reply, updates[i], plugin)) {
+            ERROR("Failed to update container resources in plugin result");
+            return false;
+        }
+    }
+
+    return true;
+}
+
+auto pluginResult::GetContainerUpdate(nri_container_update *update, const std::string &plugin,
+                                      nri_container_update **out) -> bool
+{
+    if (update == nullptr || out == nullptr || plugin.empty()) {
+        ERROR("Empyt input args");
+        return false;
+    }
+
+    auto id = update->container_id;
+
+    if (std::string(id) == m_conId) {
+        ERROR("Plugin %s asked update of %s during creation", plugin.c_str(), id);
+        return false;
+    }
+
+    auto find = m_updates.find(id);
+    if (find != m_updates.end()) {
+        *out = m_updates[id];
+        (*out)->ignore_failure = (*out)->ignore_failure && update->ignore_failure;
+        return true;
+    }
+
+    *out = init_nri_container_update(id, update->ignore_failure);
+    if (*out == nullptr) {
+        ERROR("Failed to init nri container update");
+        return false;
+    }
+
+    m_updates[id] = *out;
+
+    // for update requests delay appending the requested container (in the response getter)
+    if (m_conId != id) {
+        m_reply.update.push_back(*out);
+    }
+
+    return true;
+}
+
+auto pluginResult::UpdateResources(nri_container_update *reply, nri_container_update *u,
+                                   const std::string &plugin) -> bool
+{
+    if (u->linux == nullptr || u->linux->resources == nullptr) {
+        return true;
+    }
+
+    std::string id = u->container_id;
+    nri_linux_resources *resources;
+
+    if (m_conId == id) {
+        resources = copy_nri_linux_resources(m_update_req);
+        if (resources == nullptr) {
+            ERROR("Failed to copy request's nri linux resources");
+            return false;
+        }
+    } else {
+        resources = copy_nri_linux_resources(reply->linux->resources);
+        if (resources == nullptr) {
+            ERROR("Failed to copy reply's nri linux resources");
+            return false;
+        }
+    }
+
+    if (!ClaimAndCopyResources(u->linux->resources, id, plugin, resources)) {
+        ERROR("Failed to claim and copy resources in plugin result");
+        return false;
+    }
+
+    // update reply from copy on success
+    reply->linux->resources = copy_nri_linux_resources(resources);
+    if (reply->linux->resources == nullptr) {
+        ERROR("Failed to copy resources's nri linux resources to reply");
+        return false;
+    }
+
+    return true;
+}
\ No newline at end of file
diff --git a/src/daemon/nri/nri_result.h b/src/daemon/nri/nri_result.h
index f2896ea0..4f26385a 100644
--- a/src/daemon/nri/nri_result.h
+++ b/src/daemon/nri/nri_result.h
@@ -63,7 +63,7 @@ struct owners {
 
 struct resultReply {
     nri_container_adjustment* adjust;
-    std::vector<nri_container_update*> update;
+    std::vector<nri_container_update *> update;
 };
 
 using resultOwners = std::map<std::string, owners>;
@@ -71,16 +71,19 @@ using resultOwners = std::map<std::string, owners>;
 class pluginResult {
 public:
     pluginResult() = default;
+    pluginResult(std::string conId);
 
-    ~pluginResult() = default;
+    virtual ~pluginResult();
 
+    auto Init() -> bool;
     auto InitByConId(std::string conId) -> bool;
     auto InitByUpdateReq(nri_update_container_request *req) -> bool;
 
     auto GetReplyUpdate() -> std::vector<nri_container_update *>;
-    auto GetReplyAdjust() -> nri_container_adjustment *;
+    auto MoveReplyAdjust() -> nri_container_adjustment *;
+    auto GetReplyResources(const std::string &id) -> const nri_linux_resources *;
 
-    auto Apply(int32_t event, nri_container_adjustment *adjust, nri_container_update **update, size_t update_len,
+    auto Apply(int32_t event, const nri_container_adjustment *adjust, nri_container_update **update, size_t update_len,
                const std::string &plugin) -> bool;
     auto Update(nri_container_update **updates, size_t update_len, const std::string &plugin) -> bool;
 
@@ -90,12 +93,12 @@ private:
 
     auto InitReply(void) -> bool;
 
-    auto Adjust(nri_container_adjustment *adjust, const std::string &plugin) -> bool;
+    auto Adjust(const nri_container_adjustment *adjust, const std::string &plugin) -> bool;
 
     auto AdjustAnnotations(json_map_string_string *annos, const std::string &plugin) -> bool;
     auto AdjustMounts(nri_mount **mounts, size_t mounts_size, const std::string &plugin) -> bool;
     auto AdjustEnv(nri_key_value **envs, size_t envs_size, const std::string &plugin) -> bool;
-    auto AdjustHooks(nri_hooks *hooks, const std::string &plugin) -> bool;
+    auto AdjustHooks(const nri_hooks *hooks, const std::string &plugin) -> bool;
     auto AdjustDevices(nri_linux_device **devices, size_t devices_size, const std::string &plugin) -> bool;
     auto AdjustResources(nri_linux_resources *resources, const std::string &plugin) -> bool;
     bool ClaimAndCopyResources(nri_linux_resources *src, std::string &id, const std::string &plugin,
@@ -107,7 +110,9 @@ private:
     std::string m_conId;
     nri_linux_resources *m_update_req;
     resultReply m_reply;
+    // update plugin -> update context
     std::map<std::string, nri_container_update *> m_updates;
+    // adjust plugin -> adjust context
     resultOwners m_owners;
 };
 
diff --git a/src/daemon/nri/plugin.cc b/src/daemon/nri/plugin.cc
new file mode 100644
index 00000000..904677c4
--- /dev/null
+++ b/src/daemon/nri/plugin.cc
@@ -0,0 +1,417 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2024. All rights reserved.
+ * iSulad licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *     http://license.coscl.org.cn/MulanPSL2
+ * 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 v2 for more details.
+ * Author: zhongtao
+ * Create: 2024-03-15
+ * Description: provide plugin class definition
+ *********************************************************************************/
+
+#include "plugin.h"
+
+#include <string>
+#include <mutex>
+#include <google/protobuf/map.h>
+#include <iostream>
+#include <thread>
+#include <chrono>
+#include <sys/socket.h>
+#include <fcntl.h>
+
+#include <nri_plugin.h>
+
+#include <isula_libutils/log.h>
+#include <isula_libutils/nri_create_container_request.h>
+#include <isula_libutils/nri_create_container_response.h>
+#include <isula_libutils/nri_configure_request.h>
+#include <isula_libutils/nri_configure_response.h>
+#include <isula_libutils/nri_state_change_event.h>
+#include <isula_libutils/nri_stop_container_request.h>
+#include <isula_libutils/nri_stop_container_response.h>
+#include <isula_libutils/nri_synchronize_request.h>
+#include <isula_libutils/nri_synchronize_response.h>
+#include <isula_libutils/nri_update_container_request.h>
+#include <isula_libutils/nri_update_container_response.h>
+
+#include "utils.h"
+#include "cstruct_wrapper.h"
+
+// same as containerd
+std::string DefaultNRIVersion = "2.0.0-beta.2+unknown";
+// same as containerd
+std::string DefaultNRIRuntimeName = "v2";
+// defualt timeout for wait: 2s
+const int64_t DefaultWaitTimeout = 2000;
+const uint64_t SECOND_TO_NANOS = 1000000000;
+
+// init client conn
+NRIPlugin::NRIPlugin(std::string &idx, std::string &name, std::string &config)
+{
+    m_idx = idx;
+    m_name = name;
+    m_config = config;
+    m_closed = false;
+    m_external = false;
+    m_pid = -1;
+}
+
+NRIPlugin::NRIPlugin(int fd, std::string &name)
+{
+    m_sockFds.push_back(fd);
+    m_name = name;
+    m_closed = false;
+    m_external = true;
+    m_pid = -1;
+}
+
+// wait for plugin to register, then configure it.
+auto NRIPlugin::Start(int64_t registry_timeout, int64_t request_timeout) -> bool
+{
+    Errors error;
+
+    // todo: what if timeout is 0 or other invalid value?
+
+    if (!Connect(request_timeout)) {
+        ERROR("Failed to connect nri plugin %s", m_name.c_str());
+        return false;
+    }
+
+    if (!WaitForReady(registry_timeout)) {
+        ERROR("Failed to wait plugin %s ready with timeout %ld", m_name.c_str(), registry_timeout);
+        return false;
+    }
+
+    if (!Configure(error)) {
+        ERROR("Failed to configure nri plugin %s", m_name.c_str());
+        return false;
+    }
+
+    return true;
+}
+
+auto NRIPlugin::shutdown() -> void
+{
+    if (!Close()) {
+        ERROR("Failed to close plugin %s", m_name.c_str());
+    }
+
+    if (!Stop()) {
+        ERROR("Failed to stop plugin %s", m_name.c_str());
+    }
+}
+
+// create client connect
+auto NRIPlugin::Connect(int64_t timeout) -> bool
+{
+    if (m_name.empty()) {
+        ERROR("Empty nri plugin name");
+        return false;
+    }
+
+    if (nri_plugin_connect(m_name.c_str(), m_sockFds[0], timeout * SECOND_TO_NANOS) != 0) {
+        ERROR("Failed to create a new client for plugin %s", m_name.c_str());
+        return false;
+    }
+
+    return true;
+}
+
+// close a plugin shutting down its multiplexed ttrpc connections.
+auto NRIPlugin::Close() -> bool
+{
+    if (IsClose()) {
+        return true;
+    }
+
+    if (nri_plugin_disconnect(m_name.c_str()) != 0) {
+        ERROR("Failed to close plugin %s", m_name.c_str());
+        return false;
+    }
+
+    SetClose();
+    return true;
+}
+
+// stop a plugin (if it was launched by us)
+auto NRIPlugin::Stop() -> bool
+{
+    if (m_external) {
+        return true;
+    }
+
+    if (m_pid <= 0) {
+        WARN("Invalid pid %d", m_pid);
+        return false;
+    }
+
+    int nret = kill(m_pid, SIGKILL);
+    if (nret < 0 && errno != ESRCH) {
+        SYSWARN("Can not kill process (pid=%d) with SIGKILL", m_pid);
+        return false;
+    }
+
+    if (util_waitpid_with_timeout(m_pid, DefaultWaitTimeout, NULL) != 0) {
+        WARN("Failed to wait for plugin %s to exit", m_name.c_str());
+        return false;
+    }
+    return true;
+}
+
+// Name returns a string indentication for the plugin.
+auto NRIPlugin::GetName() -> const std::string &
+{
+    return m_name;
+}
+
+auto NRIPlugin::GetIndex() -> const std::string &
+{
+    return m_idx;
+}
+
+auto NRIPlugin::GetPeerSockFd() -> uint32_t
+{
+    return m_sockFds[1];
+}
+
+auto NRIPlugin::GetQualifiedName() -> std::string
+{
+    return m_idx + "-" +  m_name;
+}
+
+void NRIPlugin::SetReady(void)
+{
+    std::unique_lock<std::mutex> lock(m_readyMutex);
+    m_ready = true;
+    m_condition.notify_one();
+}
+
+void NRIPlugin::SetPid(int pid)
+{
+    m_pid = pid;
+}
+
+auto NRIPlugin::CreateSocketPair() -> bool
+{
+    int fds[2];
+
+    if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == -1) {
+        ERROR("Failed to create socketpair");
+        return false;
+    }
+
+    m_sockFds.push_back(fds[0]);
+    m_sockFds.push_back(fds[1]);
+    return true;
+}
+
+auto NRIPlugin::Configure(Errors &error) -> bool
+{
+    auto req = makeUniquePtrCStructWrapper<nri_configure_request>(free_nri_configure_request);
+    if (req == nullptr) {
+        ERROR("Out of memory");
+        return false;
+    }
+
+    req->get()->config = isula_strdup_s(m_config.c_str());
+    req->get()->runtime_name = isula_strdup_s(NRIRruntime.c_str());
+    req->get()->runtime_version = isula_strdup_s(NRIVersion.c_str());
+
+    nri_configure_response *resp = nullptr;
+    if (nri_plugin_configure(m_name.c_str(), req->get(), &resp) != 0) {
+        ERROR("Failed to configure plugin %s", m_name.c_str());
+        return false;
+    }
+
+    auto resp_wrapper = makeUniquePtrCStructWrapper<nri_configure_response>(resp, free_nri_configure_response);
+    if (resp_wrapper == nullptr) {
+        ERROR("Out of memory");
+        return false;
+    }
+
+    EventMask events = resp_wrapper->get()->events;
+    if (events != 0) {
+        EventMask extra = events & ~ValidEvents;
+        if (extra != 0) {
+            ERROR("Invalid plugin events: %d", extra);
+            return false;
+        }
+    } else {
+        events = ValidEvents;
+    }
+
+    m_events = events;
+    return true;
+}
+
+auto NRIPlugin::Synchronize(std::vector<nri_pod_sandbox *> &pods, std::vector<nri_container *> &containers,
+                            nri_container_update ***update, size_t update_len, Errors &error) -> bool
+{
+    size_t i;
+
+    auto req = makeUniquePtrCStructWrapper<nri_synchronize_request>(free_nri_synchronize_request);
+    if (req == nullptr) {
+        ERROR("Out of memory");
+        return false;
+    }
+
+    if (pods.size() != 0) {
+        req->get()->pods = (nri_pod_sandbox **)util_common_calloc_s(pods.size() * sizeof(nri_pod_sandbox *));
+        if (req->get()->pods == nullptr) {
+            ERROR("Out of memory");
+            return false;
+        }
+
+        for (i = 0; i < pods.size(); i++) {
+            req->get()->pods[i] = pods[i];
+            req->get()->pods_len++;
+        }
+    }
+
+    if (containers.size() != 0) {
+        req->get()->containers = (nri_container **)util_common_calloc_s(containers.size() * sizeof(nri_container *));
+        if (req->get()->containers == nullptr) {
+            ERROR("Out of memory");
+            return false;
+        }
+
+        for (i = 0; i < containers.size(); i++) {
+            req->get()->containers[i] = containers[i];
+            req->get()->containers_len++;
+        }
+    }
+
+    nri_synchronize_response *resp = nullptr;
+    if (nri_plugin_synchronize(m_name.c_str(), req->get(), &resp) != 0) {
+        ERROR("Failed to synchronize plugin %s", m_name.c_str());
+        return false;
+    }
+
+    auto resp_wrapper = makeUniquePtrCStructWrapper<nri_synchronize_response>(resp, free_nri_synchronize_response);
+    if (resp_wrapper == nullptr) {
+        ERROR("Out of memory");
+        return false;
+    }
+
+    *update = resp->update;
+    resp->update = nullptr;
+    update_len = resp->update_len;
+    resp->update_len = 0;
+    return true;
+}
+
+auto NRIPlugin::CreateContainer(nri_create_container_request *req, nri_create_container_response **resp,
+                                Errors &error) -> bool
+{
+    if (req == nullptr) {
+        ERROR("Invalid input");
+        return false;
+    }
+
+    if (IsSetEvent(CREATE_CONTAINER) == false) {
+        return true;
+    }
+
+    if (nri_plugin_create_container(m_name.c_str(), req, resp) != 0) {
+        ERROR("Failed to create container by plugin %s", m_name.c_str());
+        return false;
+    }
+
+    return true;
+}
+
+auto NRIPlugin::UpdateContainer(nri_update_container_request *req, nri_update_container_response **resp,
+                                Errors &error) -> bool
+{
+    if (req == nullptr) {
+        ERROR("Invalid input");
+        return false;
+    }
+
+    if (!IsSetEvent(UPDATE_CONTAINER)) {
+        return true;
+    }
+
+    if (nri_plugin_update_container(m_name.c_str(), req, resp) != 0) {
+        ERROR("Failed to update container by plugin %s", m_name.c_str());
+        return false;
+    }
+    return true;
+}
+
+auto NRIPlugin::StopContainer(nri_stop_container_request *req, nri_stop_container_response **resp,
+                              Errors &error) -> bool
+{
+    if (req == nullptr) {
+        ERROR("Invalid input");
+        return false;
+    }
+
+    if (!IsSetEvent(STOP_CONTAINER)) {
+        return true;
+    }
+
+    if (nri_plugin_stop_container(m_name.c_str(), req, resp) != 0) {
+        ERROR("Failed to stop container by plugin %s", m_name.c_str());
+        return false;
+    }
+    return true;
+}
+
+// do nothing with event
+auto NRIPlugin::StateChange(nri_state_change_event *evt, Errors &error) -> bool
+{
+    if (evt == nullptr) {
+        ERROR("Invalid input");
+        return false;
+    }
+
+    if (!IsSetEvent(evt->event)) {
+        return true;
+    }
+
+    if (nri_plugin_state_change(m_name.c_str(), evt) != 0) {
+        ERROR("Failed to state change by plugin %s", m_name.c_str());
+        return false;
+    }
+    return true;
+}
+
+auto NRIPlugin::WaitForReady(int64_t timeout) -> bool
+{
+    auto deadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(timeout * 1000);
+    std::unique_lock<std::mutex> readyMutex(m_readyMutex);
+
+    if (timeout == 0) {
+        m_condition.wait(readyMutex);
+        return true;
+    }
+
+    if (m_condition.wait_until(readyMutex, deadline) == std::cv_status::timeout) {
+        return false;
+    }
+
+    return true;
+}
+
+auto NRIPlugin::IsSetEvent(EventMask e) -> bool
+{
+    return (m_events & (1 << (e - 1))) != 0;
+}
+
+auto NRIPlugin::IsClose() -> bool
+{
+    ReadGuard<RWMutex> lock(m_mutex);
+    return m_closed;
+}
+
+void NRIPlugin::SetClose()
+{
+    WriteGuard<RWMutex> lock(m_mutex);
+    m_closed = true;
+}
\ No newline at end of file
diff --git a/src/daemon/nri/plugin.h b/src/daemon/nri/plugin.h
index f60a9b3d..ed298be6 100644
--- a/src/daemon/nri/plugin.h
+++ b/src/daemon/nri/plugin.h
@@ -38,17 +38,14 @@ public:
     virtual ~NRIPlugin() = default;
     // wait for plugin to register, then configure it.
     auto Start(int64_t registry_timeout, int64_t request_timeout) -> bool;
-    // close a plugin shutting down its multiplexed ttrpc connections.
-    auto Close(void) -> bool;
-    // stop a plugin (if it was launched by us)
-    auto Stop(void) -> bool;
+
+    auto shutdown() -> void;
 
     // Name returns a string indentication for the plugin.
     auto GetName(void) -> const std::string &;
     auto GetIndex(void) -> const std::string &;
     auto GetPeerSockFd(void) -> uint32_t;
     auto GetQualifiedName(void) -> std::string;
-
     void SetReady(void);
     void SetPid(int pid);
 
@@ -58,8 +55,8 @@ public:
 
     auto Configure(Errors &error) -> bool;
     // Only called in external plugin scenario
-    auto Synchronize(std::vector<std::unique_ptr<nri_pod_sandbox>> pods,
-                     std::vector<std::unique_ptr<nri_container>> &containers, nri_container_update ***update, size_t update_len,
+    auto Synchronize(std::vector<nri_pod_sandbox *> &pods,
+                     std::vector<nri_container *> &containers, nri_container_update ***update, size_t update_len,
                      Errors &error) -> bool;
     auto CreateContainer(nri_create_container_request *req, nri_create_container_response **resp, Errors &error) -> bool;
     auto UpdateContainer(nri_update_container_request *req, nri_update_container_response **resp, Errors &error) -> bool;
@@ -72,6 +69,13 @@ private:
     auto WaitForReady(int64_t timeout) -> bool;
     auto IsSetEvent(EventMask e) -> bool;
 
+    // close a plugin shutting down its multiplexed ttrpc connections.
+    auto Close(void) -> bool;
+    // stop a plugin (if it was launched by us)
+    auto Stop(void) -> bool;
+
+    void SetClose(void);
+
 private:
     RWMutex m_mutex;
     bool m_external;
@@ -83,7 +87,7 @@ private:
     std::vector<uint32_t> m_sockFds;
     std::string m_localFileName;
     std::string m_peerFileName;
-    // TODO:zhontao monitor?
+    // TODO: plugin monitor?
     bool m_closed;
     std::mutex m_readyMutex;
     bool m_ready;
diff --git a/src/utils/cutils/utils.c b/src/utils/cutils/utils.c
index f81a9141..69f6dbf0 100644
--- a/src/utils/cutils/utils.c
+++ b/src/utils/cutils/utils.c
@@ -1705,4 +1705,4 @@ void set_child_process_pdeathsig(void)
     if (prctl(PR_SET_PDEATHSIG, SIGKILL) < 0) {
         SYSERROR("Failed to set child process pdeathsig");
     }
-}
\ No newline at end of file
+}
-- 
2.25.1

