代码拉取完成，页面将自动刷新
同步操作将从 src-openEuler/iSulad 强制同步，此操作会覆盖自 Fork 仓库以来所做的任何修改，且无法恢复！！！
确定后同步将在后台操作，完成时将刷新页面，请耐心等待。
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 121/121] [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
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。
马建仓 AI 助手