1133 lines
36 KiB
C++
1133 lines
36 KiB
C++
/******************************************************************************
|
|
* Copyright (c) Huawei Technologies Co., Ltd. 2018-2019. All rights reserved.
|
|
* iSulad licensed under the Mulan PSL v1.
|
|
* You can use this software according to the terms and conditions of the Mulan PSL v1.
|
|
* You may obtain a copy of Mulan PSL v1 at:
|
|
* http://license.coscl.org.cn/MulanPSL
|
|
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
|
|
* PURPOSE.
|
|
* See the Mulan PSL v1 for more details.
|
|
* Author: lifeng
|
|
* Create: 2018-11-08
|
|
* Description: provide grpc container service private functions
|
|
******************************************************************************/
|
|
#include "grpc_containers_service.h"
|
|
#include "log.h"
|
|
#include "utils.h"
|
|
#include "error.h"
|
|
|
|
int ContainerServiceImpl::version_request_from_grpc(const VersionRequest *grequest, container_version_request **request)
|
|
{
|
|
container_version_request *tmpreq = nullptr;
|
|
|
|
tmpreq = (container_version_request *)util_common_calloc_s(sizeof(container_version_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::version_response_to_grpc(const container_version_response *response,
|
|
VersionResponse *gresponse)
|
|
{
|
|
if (response == nullptr) {
|
|
gresponse->set_cc(ISULAD_ERR_MEMOUT);
|
|
return 0;
|
|
}
|
|
gresponse->set_cc(response->cc);
|
|
if (response->errmsg != nullptr) {
|
|
gresponse->set_errmsg(response->errmsg);
|
|
}
|
|
if (response->version != nullptr) {
|
|
gresponse->set_version(response->version);
|
|
}
|
|
if (response->git_commit != nullptr) {
|
|
gresponse->set_git_commit(response->git_commit);
|
|
}
|
|
if (response->build_time != nullptr) {
|
|
gresponse->set_build_time(response->build_time);
|
|
}
|
|
if (response->root_path != nullptr) {
|
|
gresponse->set_root_path(response->root_path);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::info_request_from_grpc(const InfoRequest *grequest, host_info_request **request)
|
|
{
|
|
host_info_request *tmpreq = (host_info_request *)util_common_calloc_s(sizeof(host_info_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::info_response_to_grpc(const host_info_response *response, InfoResponse *gresponse)
|
|
{
|
|
if (response == nullptr) {
|
|
gresponse->set_cc(ISULAD_ERR_MEMOUT);
|
|
return 0;
|
|
}
|
|
|
|
gresponse->set_cc(response->cc);
|
|
if (response->errmsg != nullptr) {
|
|
gresponse->set_errmsg(response->errmsg);
|
|
}
|
|
if (response->version != nullptr) {
|
|
gresponse->set_version(response->version);
|
|
}
|
|
gresponse->set_containers_num((::google::protobuf::uint32)response->containers_num);
|
|
|
|
gresponse->set_c_running((::google::protobuf::uint32)response->c_running);
|
|
|
|
gresponse->set_c_paused((::google::protobuf::uint32)response->c_paused);
|
|
|
|
gresponse->set_c_stopped((::google::protobuf::uint32)response->c_stopped);
|
|
|
|
gresponse->set_images_num(response->images_num);
|
|
|
|
if (pack_os_info_to_grpc(response, gresponse)) {
|
|
return -1;
|
|
}
|
|
|
|
if (response->logging_driver != nullptr) {
|
|
gresponse->set_logging_driver(response->logging_driver);
|
|
}
|
|
|
|
if (response->isulad_root_dir != nullptr) {
|
|
gresponse->set_isulad_root_dir(response->isulad_root_dir);
|
|
}
|
|
|
|
gresponse->set_total_mem(response->total_mem);
|
|
|
|
if (pack_proxy_info_to_grpc(response, gresponse)) {
|
|
return -1;
|
|
}
|
|
|
|
if (pack_driver_info_to_grpc(response, gresponse)) {
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::create_request_from_grpc(const CreateRequest *grequest, container_create_request **request)
|
|
{
|
|
container_create_request *tmpreq = nullptr;
|
|
|
|
tmpreq = (container_create_request *)util_common_calloc_s(sizeof(container_create_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->id().empty()) {
|
|
tmpreq->id = util_strdup_s(grequest->id().c_str());
|
|
}
|
|
if (!grequest->rootfs().empty()) {
|
|
tmpreq->rootfs = util_strdup_s(grequest->rootfs().c_str());
|
|
}
|
|
if (!grequest->image().empty()) {
|
|
tmpreq->image = util_strdup_s(grequest->image().c_str());
|
|
}
|
|
if (!grequest->runtime().empty()) {
|
|
tmpreq->runtime = util_strdup_s(grequest->runtime().c_str());
|
|
}
|
|
if (!grequest->hostconfig().empty()) {
|
|
tmpreq->hostconfig = util_strdup_s(grequest->hostconfig().c_str());
|
|
}
|
|
if (!grequest->customconfig().empty()) {
|
|
tmpreq->customconfig = util_strdup_s(grequest->customconfig().c_str());
|
|
}
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
|
|
int ContainerServiceImpl::create_response_to_grpc(const container_create_response *response, CreateResponse *gresponse)
|
|
{
|
|
if (response == nullptr) {
|
|
gresponse->set_cc(ISULAD_ERR_MEMOUT);
|
|
return 0;
|
|
}
|
|
gresponse->set_cc(response->cc);
|
|
if (response->errmsg != nullptr) {
|
|
gresponse->set_errmsg(response->errmsg);
|
|
}
|
|
if (response->id != nullptr) {
|
|
gresponse->set_id(response->id);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::start_request_from_grpc(const StartRequest *grequest, container_start_request **request)
|
|
{
|
|
container_start_request *tmpreq = nullptr;
|
|
|
|
tmpreq = (container_start_request *)util_common_calloc_s(sizeof(container_start_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->id().empty()) {
|
|
tmpreq->id = util_strdup_s(grequest->id().c_str());
|
|
}
|
|
|
|
if (!grequest->stdin().empty()) {
|
|
tmpreq->stdin = util_strdup_s(grequest->stdin().c_str());
|
|
}
|
|
if (!grequest->stdout().empty()) {
|
|
tmpreq->stdout = util_strdup_s(grequest->stdout().c_str());
|
|
}
|
|
if (!grequest->stderr().empty()) {
|
|
tmpreq->stderr = util_strdup_s(grequest->stderr().c_str());
|
|
}
|
|
tmpreq->attach_stdin = grequest->attach_stdin();
|
|
tmpreq->attach_stdout = grequest->attach_stdout();
|
|
tmpreq->attach_stderr = grequest->attach_stderr();
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::top_request_from_grpc(const TopRequest *grequest, container_top_request **request)
|
|
{
|
|
container_top_request *tmpreq = nullptr;
|
|
|
|
tmpreq = (container_top_request *)util_common_calloc_s(sizeof(container_top_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->id().empty()) {
|
|
tmpreq->id = util_strdup_s(grequest->id().c_str());
|
|
}
|
|
|
|
if (grequest->args_size() > 0) {
|
|
if ((size_t)grequest->args_size() > SIZE_MAX / sizeof(char *)) {
|
|
ERROR("Too many arguments!");
|
|
free_container_top_request(tmpreq);
|
|
return -1;
|
|
}
|
|
tmpreq->args = (char **)util_common_calloc_s(sizeof(char *) * grequest->args_size());
|
|
if (tmpreq->args == nullptr) {
|
|
ERROR("Out of memory");
|
|
free_container_top_request(tmpreq);
|
|
return -1;
|
|
}
|
|
for (int i = 0; i < grequest->args_size(); i++) {
|
|
tmpreq->args[i] = util_strdup_s(grequest->args(i).c_str());
|
|
}
|
|
tmpreq->args_len = (size_t)grequest->args_size();
|
|
}
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::top_response_to_grpc(const container_top_response *response, TopResponse *gresponse)
|
|
{
|
|
if (response == nullptr) {
|
|
gresponse->set_cc(ISULAD_ERR_MEMOUT);
|
|
return 0;
|
|
}
|
|
gresponse->set_cc(response->cc);
|
|
if (response->errmsg != nullptr) {
|
|
gresponse->set_errmsg(response->errmsg);
|
|
}
|
|
|
|
if (response->titles != nullptr) {
|
|
gresponse->set_titles(response->titles);
|
|
}
|
|
|
|
for (size_t i = 0; i < response->processes_len; i++) {
|
|
gresponse->add_processes(response->processes[i]);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::stop_request_from_grpc(const StopRequest *grequest, container_stop_request **request)
|
|
{
|
|
container_stop_request *tmpreq = (container_stop_request *)util_common_calloc_s(sizeof(container_stop_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->id().empty()) {
|
|
tmpreq->id = util_strdup_s(grequest->id().c_str());
|
|
}
|
|
tmpreq->force = grequest->force();
|
|
tmpreq->timeout = grequest->timeout();
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::restart_request_from_grpc(const RestartRequest *grequest, container_restart_request **request)
|
|
{
|
|
container_restart_request *tmpreq = (container_restart_request *)util_common_calloc_s(
|
|
sizeof(container_restart_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->id().empty()) {
|
|
tmpreq->id = util_strdup_s(grequest->id().c_str());
|
|
}
|
|
tmpreq->timeout = grequest->timeout();
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::kill_request_from_grpc(const KillRequest *grequest, container_kill_request **request)
|
|
{
|
|
container_kill_request *tmpreq = (container_kill_request *)util_common_calloc_s(sizeof(container_kill_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->id().empty()) {
|
|
tmpreq->id = util_strdup_s(grequest->id().c_str());
|
|
}
|
|
|
|
tmpreq->signal = grequest->signal();
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::delete_request_from_grpc(const DeleteRequest *grequest, container_delete_request **request)
|
|
{
|
|
container_delete_request *tmpreq = (container_delete_request *)util_common_calloc_s(
|
|
sizeof(container_delete_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->id().empty()) {
|
|
tmpreq->id = util_strdup_s(grequest->id().c_str());
|
|
}
|
|
tmpreq->force = grequest->force();
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::delete_response_to_grpc(const container_delete_response *response, DeleteResponse *gresponse)
|
|
{
|
|
if (response == nullptr) {
|
|
gresponse->set_cc(ISULAD_ERR_MEMOUT);
|
|
return 0;
|
|
}
|
|
gresponse->set_cc(response->cc);
|
|
if (response->id != nullptr) {
|
|
gresponse->set_id(response->id);
|
|
}
|
|
if (response->errmsg != nullptr) {
|
|
gresponse->set_errmsg(response->errmsg);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::exec_request_from_grpc(const ExecRequest *grequest, container_exec_request **request)
|
|
{
|
|
container_exec_request *tmpreq = (container_exec_request *)util_common_calloc_s(sizeof(container_exec_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->container_id().empty()) {
|
|
tmpreq->container_id = util_strdup_s(grequest->container_id().c_str());
|
|
}
|
|
|
|
if (!grequest->suffix().empty()) {
|
|
tmpreq->suffix = util_strdup_s(grequest->suffix().c_str());
|
|
}
|
|
|
|
tmpreq->tty = grequest->tty();
|
|
tmpreq->attach_stdin = grequest->attach_stdin();
|
|
tmpreq->attach_stdout = grequest->attach_stdout();
|
|
tmpreq->attach_stderr = grequest->attach_stderr();
|
|
|
|
if (!grequest->stdin().empty()) {
|
|
tmpreq->stdin = util_strdup_s(grequest->stdin().c_str());
|
|
}
|
|
if (!grequest->stdout().empty()) {
|
|
tmpreq->stdout = util_strdup_s(grequest->stdout().c_str());
|
|
}
|
|
if (!grequest->stderr().empty()) {
|
|
tmpreq->stderr = util_strdup_s(grequest->stderr().c_str());
|
|
}
|
|
|
|
if (grequest->argv_size() > 0) {
|
|
if ((size_t)grequest->argv_size() > SIZE_MAX / sizeof(char *)) {
|
|
ERROR("Too many arguments!");
|
|
free_container_exec_request(tmpreq);
|
|
return -1;
|
|
}
|
|
tmpreq->argv = (char **)util_common_calloc_s(sizeof(char *) * grequest->argv_size());
|
|
if (tmpreq->argv == nullptr) {
|
|
ERROR("Out of memory");
|
|
free_container_exec_request(tmpreq);
|
|
return -1;
|
|
}
|
|
for (int i = 0; i < grequest->argv_size(); i++) {
|
|
tmpreq->argv[i] = util_strdup_s(grequest->argv(i).c_str());
|
|
}
|
|
tmpreq->argv_len = grequest->argv_size();
|
|
}
|
|
|
|
if (grequest->env_size() > 0) {
|
|
if ((size_t)grequest->argv_size() > SIZE_MAX / sizeof(char *)) {
|
|
ERROR("Too many environmental variables!");
|
|
free_container_exec_request(tmpreq);
|
|
return -1;
|
|
}
|
|
tmpreq->env = (char **)util_common_calloc_s(sizeof(char *) * grequest->env_size());
|
|
if (tmpreq->env == nullptr) {
|
|
ERROR("Out of memory");
|
|
free_container_exec_request(tmpreq);
|
|
return -1;
|
|
}
|
|
for (int i = 0; i < grequest->env_size(); i++) {
|
|
tmpreq->env[i] = util_strdup_s(grequest->env(i).c_str());
|
|
}
|
|
tmpreq->env_len = grequest->env_size();
|
|
}
|
|
|
|
if (!grequest->user().empty()) {
|
|
tmpreq->user = util_strdup_s(grequest->user().c_str());
|
|
}
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::exec_response_to_grpc(const container_exec_response *response, ExecResponse *gresponse)
|
|
{
|
|
if (response == nullptr) {
|
|
gresponse->set_cc(ISULAD_ERR_MEMOUT);
|
|
return 0;
|
|
}
|
|
|
|
gresponse->set_cc(response->cc);
|
|
gresponse->set_exit_code(response->exit_code);
|
|
if (response->errmsg != nullptr) {
|
|
gresponse->set_errmsg(response->errmsg);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::inspect_request_from_grpc(const InspectContainerRequest *grequest,
|
|
container_inspect_request **request)
|
|
{
|
|
container_inspect_request *tmpreq = (container_inspect_request *)util_common_calloc_s(
|
|
sizeof(container_inspect_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->id().empty()) {
|
|
tmpreq->id = util_strdup_s(grequest->id().c_str());
|
|
}
|
|
|
|
tmpreq->bformat = grequest->bformat();
|
|
tmpreq->timeout = grequest->timeout();
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::inspect_response_to_grpc(const container_inspect_response *response,
|
|
InspectContainerResponse *gresponse)
|
|
{
|
|
if (response == nullptr) {
|
|
gresponse->set_cc(ISULAD_ERR_MEMOUT);
|
|
return 0;
|
|
}
|
|
|
|
gresponse->set_cc(response->cc);
|
|
if (response->container_json != nullptr) {
|
|
gresponse->set_containerjson(response->container_json);
|
|
}
|
|
if (response->errmsg != nullptr) {
|
|
gresponse->set_errmsg(response->errmsg);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::list_request_from_grpc(const ListRequest *grequest, container_list_request **request)
|
|
{
|
|
size_t len = 0;
|
|
container_list_request *tmpreq = (container_list_request *)util_common_calloc_s(
|
|
sizeof(container_list_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
tmpreq->all = grequest->all();
|
|
tmpreq->filters = (defs_filters *)util_common_calloc_s(sizeof(defs_filters));
|
|
if (tmpreq->filters == nullptr) {
|
|
ERROR("Out of memory");
|
|
goto cleanup;
|
|
}
|
|
|
|
len = (size_t)grequest->filters_size();
|
|
if (len == 0) {
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
if (len > SIZE_MAX / sizeof(char *)) {
|
|
ERROR("invalid filters size");
|
|
goto cleanup;
|
|
}
|
|
tmpreq->filters->keys = (char **)util_common_calloc_s(len * sizeof(char *));
|
|
if (tmpreq->filters->keys == nullptr) {
|
|
goto cleanup;
|
|
}
|
|
tmpreq->filters->values = (json_map_string_bool **)util_common_calloc_s(len * sizeof(json_map_string_bool *));
|
|
if (tmpreq->filters->values == nullptr) {
|
|
free(tmpreq->filters->keys);
|
|
tmpreq->filters->keys = nullptr;
|
|
goto cleanup;
|
|
}
|
|
|
|
for (auto &iter : grequest->filters()) {
|
|
tmpreq->filters->values[tmpreq->filters->len] = (json_map_string_bool *)
|
|
util_common_calloc_s(sizeof(json_map_string_bool));
|
|
if (tmpreq->filters->values[tmpreq->filters->len] == nullptr) {
|
|
ERROR("Out of memory");
|
|
goto cleanup;
|
|
}
|
|
if (append_json_map_string_bool(tmpreq->filters->values[tmpreq->filters->len],
|
|
iter.second.empty() ? "" : iter.second.c_str(), true)) {
|
|
free(tmpreq->filters->values[tmpreq->filters->len]);
|
|
tmpreq->filters->values[tmpreq->filters->len] = nullptr;
|
|
ERROR("Append failed");
|
|
goto cleanup;
|
|
}
|
|
tmpreq->filters->keys[tmpreq->filters->len] = util_strdup_s(iter.first.empty() ? "" : iter.first.c_str());
|
|
tmpreq->filters->len++;
|
|
}
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
cleanup:
|
|
free_container_list_request(tmpreq);
|
|
return -1;
|
|
}
|
|
|
|
int ContainerServiceImpl::list_response_to_grpc(const container_list_response *response, ListResponse *gresponse)
|
|
{
|
|
if (response == nullptr) {
|
|
gresponse->set_cc(ISULAD_ERR_MEMOUT);
|
|
return 0;
|
|
}
|
|
|
|
gresponse->set_cc(response->cc);
|
|
if (response->errmsg != nullptr) {
|
|
gresponse->set_errmsg(response->errmsg);
|
|
}
|
|
for (size_t i = 0; i < response->containers_len; i++) {
|
|
Container *container = gresponse->add_containers();
|
|
if (response->containers[i]->id != nullptr) {
|
|
container->set_id(response->containers[i]->id);
|
|
}
|
|
if (response->containers[i]->name != nullptr) {
|
|
container->set_name(response->containers[i]->name);
|
|
}
|
|
if (response->containers[i]->pid != 0) {
|
|
container->set_pid(response->containers[i]->pid);
|
|
}
|
|
container->set_status((ContainerStatus)response->containers[i]->status);
|
|
if (response->containers[i]->image != nullptr) {
|
|
container->set_image(response->containers[i]->image);
|
|
}
|
|
if (response->containers[i]->command != nullptr) {
|
|
container->set_command(response->containers[i]->command);
|
|
}
|
|
container->set_exit_code(response->containers[i]->exit_code);
|
|
container->set_restartcount(response->containers[i]->restartcount);
|
|
if (response->containers[i]->startat != nullptr) {
|
|
container->set_startat(response->containers[i]->startat);
|
|
}
|
|
if (response->containers[i]->finishat != nullptr) {
|
|
container->set_finishat(response->containers[i]->finishat);
|
|
}
|
|
if (response->containers[i]->runtime != nullptr) {
|
|
container->set_runtime(response->containers[i]->runtime);
|
|
}
|
|
if (response->containers[i]->health_state != nullptr) {
|
|
container->set_health_state(response->containers[i]->health_state);
|
|
}
|
|
container->set_created(response->containers[i]->created);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::pause_request_from_grpc(const PauseRequest *grequest, container_pause_request **request)
|
|
{
|
|
container_pause_request *tmpreq = (container_pause_request *)util_common_calloc_s(sizeof(container_pause_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->id().empty()) {
|
|
tmpreq->id = util_strdup_s(grequest->id().c_str());
|
|
}
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::resume_request_from_grpc(const ResumeRequest *grequest, container_resume_request **request)
|
|
{
|
|
container_resume_request *tmpreq = (container_resume_request *)util_common_calloc_s(
|
|
sizeof(container_resume_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->id().empty()) {
|
|
tmpreq->id = util_strdup_s(grequest->id().c_str());
|
|
}
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::container_rename_request_from_grpc(const RenameRequest *grequest,
|
|
struct isulad_container_rename_request **request)
|
|
{
|
|
struct isulad_container_rename_request *tmpreq = (struct isulad_container_rename_request *)util_common_calloc_s(
|
|
sizeof(struct isulad_container_rename_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->oldname().empty()) {
|
|
tmpreq->old_name = util_strdup_s(grequest->oldname().c_str());
|
|
}
|
|
|
|
if (!grequest->newname().empty()) {
|
|
tmpreq->new_name = util_strdup_s(grequest->newname().c_str());
|
|
}
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::container_rename_response_to_grpc(const struct isulad_container_rename_response *response,
|
|
RenameResponse *gresponse)
|
|
{
|
|
if (response == nullptr) {
|
|
gresponse->set_cc(ISULAD_ERR_MEMOUT);
|
|
return 0;
|
|
}
|
|
|
|
gresponse->set_cc(response->cc);
|
|
if (response->errmsg != nullptr) {
|
|
gresponse->set_errmsg(response->errmsg);
|
|
}
|
|
if (response->id != nullptr) {
|
|
gresponse->set_id(response->id);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::container_resize_request_from_grpc(const ResizeRequest *grequest,
|
|
struct isulad_container_resize_request **request)
|
|
{
|
|
struct isulad_container_resize_request *tmpreq = (struct isulad_container_resize_request *)util_common_calloc_s(
|
|
sizeof(struct isulad_container_resize_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->id().empty()) {
|
|
tmpreq->id = util_strdup_s(grequest->id().c_str());
|
|
}
|
|
|
|
if (!grequest->suffix().empty()) {
|
|
tmpreq->suffix = util_strdup_s(grequest->suffix().c_str());
|
|
}
|
|
|
|
tmpreq->height = grequest->height();
|
|
|
|
tmpreq->width = grequest->width();
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::container_resize_response_to_grpc(const struct isulad_container_resize_response *response,
|
|
ResizeResponse *gresponse)
|
|
{
|
|
if (response == nullptr) {
|
|
gresponse->set_cc(ISULAD_ERR_MEMOUT);
|
|
return 0;
|
|
}
|
|
|
|
gresponse->set_cc(response->cc);
|
|
if (response->errmsg != nullptr) {
|
|
gresponse->set_errmsg(response->errmsg);
|
|
}
|
|
if (response->id != nullptr) {
|
|
gresponse->set_id(response->id);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::update_request_from_grpc(const UpdateRequest *grequest, container_update_request **request)
|
|
{
|
|
container_update_request *tmpreq = (container_update_request *)util_common_calloc_s(
|
|
sizeof(container_update_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->id().empty()) {
|
|
tmpreq->name = util_strdup_s(grequest->id().c_str());
|
|
}
|
|
|
|
if (!grequest->hostconfig().empty()) {
|
|
tmpreq->host_config = util_strdup_s(grequest->hostconfig().c_str());
|
|
}
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::update_response_to_grpc(const container_update_response *response, UpdateResponse *gresponse)
|
|
{
|
|
if (response == nullptr) {
|
|
gresponse->set_cc(ISULAD_ERR_MEMOUT);
|
|
return 0;
|
|
}
|
|
|
|
gresponse->set_cc(response->cc);
|
|
if (response->id != nullptr) {
|
|
gresponse->set_id(response->id);
|
|
}
|
|
if (response->errmsg != nullptr) {
|
|
gresponse->set_errmsg(response->errmsg);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::stats_request_from_grpc(const StatsRequest *grequest, container_stats_request **request)
|
|
{
|
|
container_stats_request *tmpreq = (container_stats_request *)util_common_calloc_s(sizeof(container_stats_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (grequest->containers_size() > 0) {
|
|
tmpreq->containers = (char **)util_common_calloc_s(grequest->containers_size() * sizeof(char *));
|
|
if (tmpreq->containers == nullptr) {
|
|
ERROR("Out of memory");
|
|
free_container_stats_request(tmpreq);
|
|
return -1;
|
|
}
|
|
for (int i = 0; i < grequest->containers_size(); i++) {
|
|
tmpreq->containers[i] = util_strdup_s(grequest->containers(i).c_str());
|
|
tmpreq->containers_len++;
|
|
}
|
|
}
|
|
|
|
tmpreq->all = grequest->all();
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::stats_response_to_grpc(const container_stats_response *response, StatsResponse *gresponse)
|
|
{
|
|
if (response == nullptr) {
|
|
gresponse->set_cc(ISULAD_ERR_MEMOUT);
|
|
return 0;
|
|
}
|
|
|
|
if (response->container_stats && response->container_stats_len) {
|
|
for (size_t i = 0; i < response->container_stats_len; i++) {
|
|
containers::Container_info *stats = gresponse->add_containers();
|
|
if (response->container_stats[i]->id != nullptr) {
|
|
stats->set_id(response->container_stats[i]->id);
|
|
}
|
|
stats->set_pids_current(response->container_stats[i]->pids_current);
|
|
stats->set_cpu_use_nanos(response->container_stats[i]->cpu_use_nanos);
|
|
stats->set_cpu_system_use(response->container_stats[i]->cpu_system_use);
|
|
stats->set_online_cpus(response->container_stats[i]->online_cpus);
|
|
stats->set_blkio_read(response->container_stats[i]->blkio_read);
|
|
stats->set_blkio_write(response->container_stats[i]->blkio_write);
|
|
stats->set_mem_used(response->container_stats[i]->mem_used);
|
|
stats->set_mem_limit(response->container_stats[i]->mem_limit);
|
|
stats->set_kmem_used(response->container_stats[i]->kmem_used);
|
|
stats->set_kmem_limit(response->container_stats[i]->kmem_limit);
|
|
}
|
|
}
|
|
gresponse->set_cc(response->cc);
|
|
if (response->errmsg != nullptr) {
|
|
gresponse->set_errmsg(response->errmsg);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::wait_request_from_grpc(const WaitRequest *grequest, container_wait_request **request)
|
|
{
|
|
container_wait_request *tmpreq = (container_wait_request *)util_common_calloc_s(sizeof(container_wait_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->id().empty()) {
|
|
tmpreq->id = util_strdup_s(grequest->id().c_str());
|
|
}
|
|
|
|
tmpreq->condition = grequest->condition();
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::wait_response_to_grpc(const container_wait_response *response, WaitResponse *gresponse)
|
|
{
|
|
if (response == nullptr) {
|
|
gresponse->set_cc(ISULAD_ERR_MEMOUT);
|
|
return 0;
|
|
}
|
|
|
|
gresponse->set_cc(response->cc);
|
|
gresponse->set_exit_code(response->exit_code);
|
|
if (response->errmsg != nullptr) {
|
|
gresponse->set_errmsg(response->errmsg);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::events_request_from_grpc(const EventsRequest *grequest,
|
|
struct isulad_events_request **request)
|
|
{
|
|
struct isulad_events_request *tmpreq = (struct isulad_events_request *)util_common_calloc_s(
|
|
sizeof(struct isulad_events_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->id().empty()) {
|
|
tmpreq->id = util_strdup_s(grequest->id().c_str());
|
|
}
|
|
|
|
tmpreq->storeonly = grequest->storeonly();
|
|
|
|
if (grequest->has_since()) {
|
|
protobuf_timestamp_from_grpc(&tmpreq->since, grequest->since());
|
|
}
|
|
|
|
if (grequest->has_until()) {
|
|
protobuf_timestamp_from_grpc(&tmpreq->until, grequest->until());
|
|
}
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::copy_from_container_request_from_grpc(
|
|
const CopyFromContainerRequest *grequest, struct isulad_copy_from_container_request **request)
|
|
{
|
|
struct isulad_copy_from_container_request *tmpreq = (struct isulad_copy_from_container_request *)util_common_calloc_s(
|
|
sizeof(isulad_copy_from_container_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->id().empty()) {
|
|
tmpreq->id = util_strdup_s(grequest->id().c_str());
|
|
}
|
|
|
|
if (!grequest->runtime().empty()) {
|
|
tmpreq->runtime = util_strdup_s(grequest->runtime().c_str());
|
|
}
|
|
|
|
if (!grequest->srcpath().empty()) {
|
|
tmpreq->srcpath = util_strdup_s(grequest->srcpath().c_str());
|
|
}
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::remote_exec_request_from_stream(ServerContext *context,
|
|
container_exec_request **request, std::string &errmsg)
|
|
{
|
|
const std::multimap<grpc::string_ref, grpc::string_ref> init_metadata = context->client_metadata();
|
|
auto iter = init_metadata.find("isulad-remote-exec");
|
|
if (iter != init_metadata.end()) {
|
|
char *err = nullptr;
|
|
std::string json = std::string(iter->second.data(), iter->second.length());
|
|
*request = container_exec_request_parse_data(json.c_str(), nullptr, &err);
|
|
if (*request == nullptr) {
|
|
errmsg = "Invalid remote exec container json: ";
|
|
errmsg += (err != nullptr) ? err : "unknown";
|
|
free(err);
|
|
return -1;
|
|
}
|
|
} else {
|
|
errmsg = "No metadata 'isulad-remote-exec' received";
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void ContainerServiceImpl::add_exec_trailing_metadata(ServerContext *context, container_exec_response *response)
|
|
{
|
|
if (response == nullptr) {
|
|
context->AddTrailingMetadata("cc", std::to_string((int)ISULAD_ERR_MEMOUT));
|
|
return;
|
|
}
|
|
context->AddTrailingMetadata("cc", std::to_string(response->cc));
|
|
context->AddTrailingMetadata("exit_code", std::to_string(response->exit_code));
|
|
if (response->errmsg != nullptr) {
|
|
context->AddTrailingMetadata("errmsg", response->errmsg);
|
|
}
|
|
}
|
|
|
|
int ContainerServiceImpl::attach_request_from_stream(
|
|
const std::multimap<grpc::string_ref, grpc::string_ref> &metadata,
|
|
container_attach_request **request)
|
|
{
|
|
container_attach_request *tmpreq = (container_attach_request *)util_common_calloc_s(
|
|
sizeof(container_attach_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
std::multimap<grpc::string_ref, grpc::string_ref>::const_iterator std_kv;
|
|
std_kv = metadata.find("container-id");
|
|
if (std_kv == metadata.end()) {
|
|
goto cleanup;
|
|
}
|
|
tmpreq->container_id = util_strdup_s(std::string(std_kv->second.data(), std_kv->second.length()).c_str());
|
|
|
|
std_kv = metadata.find("attach-stdin");
|
|
if (std_kv == metadata.end()) {
|
|
goto cleanup;
|
|
}
|
|
tmpreq->attach_stdin = (std::string(std_kv->second.data(), std_kv->second.length()) == "true");
|
|
|
|
std_kv = metadata.find("attach-stdout");
|
|
if (std_kv == metadata.end()) {
|
|
goto cleanup;
|
|
}
|
|
tmpreq->attach_stdout = (std::string(std_kv->second.data(), std_kv->second.length()) == "true");
|
|
|
|
std_kv = metadata.find("attach-stderr");
|
|
if (std_kv == metadata.end()) {
|
|
goto cleanup;
|
|
}
|
|
tmpreq->attach_stderr = (std::string(std_kv->second.data(), std_kv->second.length()) == "true");
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
cleanup:
|
|
free_container_attach_request(tmpreq);
|
|
return -1;
|
|
}
|
|
|
|
void ContainerServiceImpl::add_attach_trailing_metadata(ServerContext *context, container_attach_response *response)
|
|
{
|
|
if (response == nullptr) {
|
|
context->AddTrailingMetadata("cc", std::to_string((int)ISULAD_ERR_MEMOUT));
|
|
return;
|
|
}
|
|
context->AddTrailingMetadata("cc", std::to_string(response->cc));
|
|
|
|
if (response->errmsg != nullptr) {
|
|
context->AddTrailingMetadata("errmsg", response->errmsg);
|
|
}
|
|
}
|
|
|
|
int ContainerServiceImpl::remote_start_request_from_stream(
|
|
const std::multimap<grpc::string_ref, grpc::string_ref> &metadata, container_start_request **request)
|
|
{
|
|
container_start_request *tmpreq = (container_start_request *)util_common_calloc_s(sizeof(container_start_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
std::multimap<grpc::string_ref, grpc::string_ref>::const_iterator std_kv;
|
|
std_kv = metadata.find("container-id");
|
|
if (std_kv == metadata.end()) {
|
|
goto cleanup;
|
|
}
|
|
tmpreq->id = util_strdup_s(std::string(std_kv->second.data(), std_kv->second.length()).c_str());
|
|
|
|
std_kv = metadata.find("attach-stdin");
|
|
if (std_kv == metadata.end()) {
|
|
goto cleanup;
|
|
}
|
|
tmpreq->attach_stdin = (std::string(std_kv->second.data(), std_kv->second.length()) == "true");
|
|
|
|
std_kv = metadata.find("attach-stdout");
|
|
if (std_kv == metadata.end()) {
|
|
goto cleanup;
|
|
}
|
|
tmpreq->attach_stdout = (std::string(std_kv->second.data(), std_kv->second.length()) == "true");
|
|
|
|
std_kv = metadata.find("attach-stderr");
|
|
if (std_kv == metadata.end()) {
|
|
goto cleanup;
|
|
}
|
|
tmpreq->attach_stderr = (std::string(std_kv->second.data(), std_kv->second.length()) == "true");
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
cleanup:
|
|
free_container_start_request(tmpreq);
|
|
return -1;
|
|
}
|
|
|
|
void ContainerServiceImpl::add_start_trailing_metadata(ServerContext *context, container_start_response *response)
|
|
{
|
|
if (response == nullptr) {
|
|
context->AddTrailingMetadata("cc", std::to_string((int)ISULAD_ERR_MEMOUT));
|
|
return;
|
|
}
|
|
context->AddTrailingMetadata("cc", std::to_string(response->cc));
|
|
|
|
if (response->errmsg != nullptr) {
|
|
context->AddTrailingMetadata("errmsg", response->errmsg);
|
|
}
|
|
}
|
|
|
|
int ContainerServiceImpl::export_request_from_grpc(const ExportRequest *grequest, container_export_request **request)
|
|
{
|
|
container_export_request *tmpreq = (container_export_request *)util_common_calloc_s(
|
|
sizeof(container_export_request));
|
|
if (tmpreq == nullptr) {
|
|
ERROR("Out of memory");
|
|
return -1;
|
|
}
|
|
|
|
if (!grequest->id().empty()) {
|
|
tmpreq->id = util_strdup_s(grequest->id().c_str());
|
|
}
|
|
|
|
if (!grequest->file().empty()) {
|
|
tmpreq->file = util_strdup_s(grequest->file().c_str());
|
|
}
|
|
|
|
*request = tmpreq;
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::pack_os_info_to_grpc(const host_info_response *response, InfoResponse *gresponse)
|
|
{
|
|
if (response == nullptr) {
|
|
gresponse->set_cc(ISULAD_ERR_MEMOUT);
|
|
return 0;
|
|
}
|
|
|
|
if (response->kversion != nullptr) {
|
|
gresponse->set_kversion(response->kversion);
|
|
}
|
|
|
|
if (response->os_type != nullptr) {
|
|
gresponse->set_os_type(response->os_type);
|
|
}
|
|
|
|
if (response->architecture != nullptr) {
|
|
gresponse->set_architecture(response->architecture);
|
|
}
|
|
|
|
if (response->nodename != nullptr) {
|
|
gresponse->set_nodename(response->nodename);
|
|
}
|
|
|
|
gresponse->set_cpus((::google::protobuf::uint32)response->cpus);
|
|
|
|
if (response->operating_system != nullptr) {
|
|
gresponse->set_operating_system(response->operating_system);
|
|
}
|
|
|
|
if (response->cgroup_driver != nullptr) {
|
|
gresponse->set_cgroup_driver(response->cgroup_driver);
|
|
}
|
|
|
|
if (response->huge_page_size != nullptr) {
|
|
gresponse->set_huge_page_size(response->huge_page_size);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::pack_proxy_info_to_grpc(const host_info_response *response, InfoResponse *gresponse)
|
|
{
|
|
if (response == nullptr) {
|
|
gresponse->set_cc(ISULAD_ERR_MEMOUT);
|
|
return 0;
|
|
}
|
|
|
|
if (response->http_proxy != nullptr) {
|
|
gresponse->set_http_proxy(response->http_proxy);
|
|
}
|
|
|
|
if (response->https_proxy != nullptr) {
|
|
gresponse->set_https_proxy(response->https_proxy);
|
|
}
|
|
|
|
if (response->no_proxy != nullptr) {
|
|
gresponse->set_no_proxy(response->no_proxy);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ContainerServiceImpl::pack_driver_info_to_grpc(const host_info_response *response, InfoResponse *gresponse)
|
|
{
|
|
if (response == nullptr) {
|
|
gresponse->set_cc(ISULAD_ERR_MEMOUT);
|
|
return 0;
|
|
}
|
|
|
|
if (response->driver_name != nullptr) {
|
|
gresponse->set_driver_name(response->driver_name);
|
|
}
|
|
|
|
if (response->driver_status != nullptr) {
|
|
gresponse->set_driver_status(response->driver_status);
|
|
}
|
|
|
|
return 0;
|
|
}
|