packages/iSulad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

iSulad: internal change

Browse Source 
Signed-off-by: LiFeng <lifeng68@huawei.com>
This commit is contained in:
LiFeng 2020-01-06 05:11:01 -05:00
parent 99a92711bd
commit e2728aa73e
47 changed files with 1606 additions and 1470 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cmake/options.cmake
View File

@ -33,7 +33,7 @@ endif()
option(VERSION "set lcrd version" ON)
if (VERSION STREQUAL "ON")
set(LCRD_VERSION "1.1.4")
set(LCRD_VERSION "1.1.5")
endif()
option(DEBUG "set lcrd gcc option" ON)

4
iSulad.spec
View File

@ -1,5 +1,5 @@
%global _version 1.1.4
%global _release 20191226.061440.gitfa7769d5
%global _version 1.1.5
%global _release 20200106.022952.git939935db
%global is_systemd 1
%global debug_package %{nil}

56
src/api/services/containers/container.proto
View File

@ -69,20 +69,18 @@ message Container {
message Container_info {
string id = 1;
int32 pid = 2;
ContainerStatus status = 3;
uint64 pids_current = 4;
uint64 cpu_use_nanos = 5;
uint64 cpu_use_user = 6;
uint64 cpu_use_kernel = 7;
uint64 cpu_system_use = 8;
uint32 online_cpus = 9;
uint64 blkio_read = 10;
uint64 blkio_write = 11;
uint64 mem_used = 12;
uint64 mem_limit = 13;
uint64 kmem_used = 14;
uint64 kmem_limit = 15;
uint64 pids_current = 2;
uint64 cpu_use_nanos = 3;
uint64 cpu_use_user = 4;
uint64 cpu_use_kernel = 5;
uint64 cpu_system_use = 6;
uint32 online_cpus = 7;
uint64 blkio_read = 8;
uint64 blkio_write = 9;
uint64 mem_used = 10;
uint64 mem_limit = 11;
uint64 kmem_used = 12;
uint64 kmem_limit = 13;
}
message Event {
@ -114,13 +112,13 @@ service ContainerService {
rpc Info(InfoRequest) returns (InfoResponse);
rpc Update(UpdateRequest) returns (UpdateResponse);
rpc Attach(stream AttachRequest) returns (stream AttachResponse);
rpc Container_conf(Container_conf_Request) returns (Container_conf_Response);
rpc Restart(RestartRequest) returns (RestartResponse);
rpc Export(ExportRequest) returns (ExportResponse);
rpc CopyFromContainer(CopyFromContainerRequest) returns (stream CopyFromContainerResponse);
rpc CopyToContainer(stream CopyToContainerRequest) returns (stream CopyToContainerResponse);
rpc Rename(RenameRequest) returns (RenameResponse);
rpc Logs(LogsRequest) returns (stream LogsResponse);
rpc Resize(ResizeRequest) returns (ResizeResponse);
}
message CreateRequest {
@ -271,7 +269,6 @@ message ListResponse {
}
message StatsRequest {
string runtime = 1;
repeated string containers = 2;
bool all = 3;
}
@ -313,6 +310,7 @@ message ExecRequest {
repeated string argv = 10;
repeated string env = 11;
string user = 12;
string suffix = 13;
}
message ExecResponse {
int32 pid = 1;
@ -390,19 +388,6 @@ message UpdateResponse {
uint32 cc = 2;
string errmsg = 3;
}
message Container_conf_Request {
// ContainerID specifies the container in which to get config.
string container_id = 1;
string runtime = 2;
}
message Container_conf_Response {
string container_logpath = 1;
string container_logsize = 2;
uint32 container_logrotate = 3;
uint32 cc = 4;
string errmsg = 5;
}
message ExportRequest {
string id = 1;
@ -461,3 +446,16 @@ message LogsResponse {
string time = 3;
bytes attrs = 4;
}
message ResizeRequest {
string id = 1;
string suffix = 2;
uint32 height = 3;
uint32 width = 4;
}
message ResizeResponse {
string id = 1;
uint32 cc = 2;
string errmsg = 3;
}

3
src/api/services/containers/rest/container.rest.h
View File

@ -45,8 +45,6 @@
#include "container_resume_response.h"
#include "container_wait_request.h"
#include "container_wait_response.h"
#include "container_conf_request.h"
#include "container_conf_response.h"
#ifndef RestHttpHead
#define RestHttpHead "http://localhost"
@ -67,7 +65,6 @@
#define ContainerServiceAttach "/ContainerService/Attach"
#define ContainerServiceResume "/ContainerService/Resume"
#define ContainerServiceWait "/ContainerService/Wait"
#define ContainerServiceConf "/ContainerService/Container_conf"
/* "/ContainerService/Kill",
"/ContainerService/Delete",

3
src/cmd/lcrc/arguments.h
View File

@ -286,6 +286,9 @@ struct client_arguments {
char *type;
char *tag;
// exec
char *exec_suffix;
// login/logout
char *username;
char *password;

1
src/cmd/lcrc/base/create.c
View File

@ -1273,7 +1273,6 @@ int cmd_create_main(int argc, const char **argv)
printf("%s\n", g_cmd_create_args.name);
nret = EXIT_SUCCESS;
out:
client_arguments_free(&g_cmd_create_args);
exit(nret);
}

100
src/cmd/lcrc/base/run.c
View File

@ -12,7 +12,11 @@
* Create: 2018-11-08
* Description: provide container run functions
******************************************************************************/
#include <sys/ioctl.h>
#include <unistd.h>
#include <pthread.h>
#include <termios.h>
#include "run.h"
#include "arguments.h"
#include "log.h"
@ -127,6 +131,97 @@ out:
return ret;
}
static int do_resize_run_console(const struct client_arguments *args, unsigned int height, unsigned int width)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
struct lcrc_resize_request request = { 0 };
struct lcrc_resize_response *response = NULL;
client_connect_config_t config = { 0 };
ops = get_connect_client_ops();
if (ops == NULL || ops->container.resize == NULL) {
ERROR("Unimplemented ops");
ret = -1;
goto out;
}
request.id = args->name;
request.height = height;
request.width = width;
response = util_common_calloc_s(sizeof(struct lcrc_resize_response));
if (response == NULL) {
ERROR("Out of memory");
ret = -1;
goto out;
}
config = get_connect_config(args);
ret = ops->container.resize(&request, response, &config);
if (ret != 0) {
ERROR("Failed to call resize");
goto out;
}
out:
lcrc_resize_response_free(response);
return ret;
}
static void *run_console_resize_thread(void *arg)
{
int ret = 0;
const struct client_arguments *args = arg;
static struct winsize s_pre_wsz;
struct winsize wsz;
if (!isatty(STDIN_FILENO)) {
goto out;
}
ret = pthread_detach(pthread_self());
if (ret != 0) {
CRIT("Start: set thread detach fail");
goto out;
}
while (true) {
sleep(1); // check the windows size per 1s
ret = ioctl(STDIN_FILENO, TIOCGWINSZ, &wsz);
if (ret < 0) {
WARN("Failed to get window size");
continue;
}
if (wsz.ws_row == s_pre_wsz.ws_row && wsz.ws_col == s_pre_wsz.ws_col) {
continue;
}
ret = do_resize_run_console(args, wsz.ws_row, wsz.ws_col);
if (ret != 0) {
continue;
}
s_pre_wsz.ws_row = wsz.ws_row;
s_pre_wsz.ws_col = wsz.ws_col;
}
out:
return NULL;
}
int run_client_console_resize_thread(struct client_arguments *args)
{
int res = 0;
pthread_t a_thread;
res = pthread_create(&a_thread, NULL, run_console_resize_thread, (void *)(args));
if (res != 0) {
CRIT("Thread creation failed");
return -1;
}
return 0;
}
int cmd_run_main(int argc, const char **argv)
{
int ret = 0;
@ -172,6 +267,10 @@ int cmd_run_main(int argc, const char **argv)
printf("%s\n", g_cmd_run_args.name);
}
if (g_cmd_run_args.custom_conf.tty && isatty(STDIN_FILENO)) {
(void)run_client_console_resize_thread(&g_cmd_run_args);
}
if (strncmp(g_cmd_run_args.socket, "tcp://", strlen("tcp://")) == 0) {
ret = remote_cmd_start(&g_cmd_run_args, &exit_code);
if (ret != 0) {
@ -187,7 +286,6 @@ int cmd_run_main(int argc, const char **argv)
}
free_out:
client_arguments_free(&g_cmd_run_args);
exit(ret);
}

1
src/cmd/lcrc/extend/stats.c
View File

@ -213,7 +213,6 @@ static int client_stats(const struct client_arguments *args)
{
struct lcrc_stats_request request = { 0 };
request.runtime = args->runtime;
request.all = args->showall;
request.containers = (char **)(args->argv);
request.containers_len = (size_t)(args->argc);

2
src/cmd/lcrc/extend/stats.h
View File

@ -18,8 +18,6 @@
#include "arguments.h"
#define STATUS_OPTIONS(cmdargs) \
{ CMD_OPT_TYPE_STRING, false, "runtime", 'R', &(cmdargs).runtime, \
"Runtime to use for containers(default: lcr)", NULL }, \
{ CMD_OPT_TYPE_BOOL, false, "all", 'a', &(cmdargs).showall, \
"Show all containers (default shows just running)", NULL }, \
{ CMD_OPT_TYPE_BOOL, false, "no-stream", 0, &(cmdargs).nostream, \

129
src/cmd/lcrc/stream/exec.c
View File

@ -18,6 +18,8 @@
#include <unistd.h>
#include <limits.h>
#include <pthread.h>
#include <sys/ioctl.h>
#include <termios.h>
#include "arguments.h"
#include "exec.h"
@ -52,6 +54,7 @@ static int client_exec(const struct client_arguments *args, const struct command
}
request.name = args->name;
request.suffix = args->exec_suffix;
request.tty = args->custom_conf.tty;
request.open_stdin = args->custom_conf.open_stdin;
request.attach_stdin = args->custom_conf.attach_stdin;
@ -248,6 +251,7 @@ static int remote_cmd_exec(const struct client_arguments *args, uint32_t *exit_c
g_cmd_exec_args.name = util_strdup_s(inspect_data->id);
request.name = args->name;
request.suffix = args->exec_suffix;
request.tty = args->custom_conf.tty;
request.open_stdin = args->custom_conf.open_stdin;
request.attach_stdin = args->custom_conf.attach_stdin;
@ -313,6 +317,119 @@ out:
return ret;
}
static char *generate_exec_suffix()
{
char *exec_suffix = NULL;
exec_suffix = util_common_calloc_s(sizeof(char) * (CONTAINER_ID_MAX_LEN + 1));
if (exec_suffix == NULL) {
ERROR("Out of memory");
goto out;
}
if (util_generate_random_str(exec_suffix, (size_t)CONTAINER_ID_MAX_LEN)) {
ERROR("Generate exec suffix failed");
free(exec_suffix);
exec_suffix = NULL;
goto out;
}
out:
return exec_suffix;
}
static int do_resize_exec_console(const struct client_arguments *args, unsigned int height, unsigned int width)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
struct lcrc_resize_request request = { 0 };
struct lcrc_resize_response *response = NULL;
client_connect_config_t config = { 0 };
ops = get_connect_client_ops();
if (ops == NULL || ops->container.resize == NULL) {
ERROR("Unimplemented ops");
ret = -1;
goto out;
}
request.id = args->name;
request.suffix = args->exec_suffix;
request.height = height;
request.width = width;
response = util_common_calloc_s(sizeof(struct lcrc_resize_response));
if (response == NULL) {
ERROR("Out of memory");
ret = -1;
goto out;
}
config = get_connect_config(args);
ret = ops->container.resize(&request, response, &config);
if (ret != 0) {
ERROR("Failed to call resize");
goto out;
}
out:
lcrc_resize_response_free(response);
return ret;
}
static void *exec_console_resize_thread(void *arg)
{
int ret = 0;
const struct client_arguments *args = arg;
static struct winsize s_pre_wsz;
struct winsize wsz;
if (!isatty(STDIN_FILENO)) {
goto out;
}
ret = pthread_detach(pthread_self());
if (ret != 0) {
CRIT("Start: set thread detach fail");
goto out;
}
while (true) {
sleep(1); // check the windows size per 1s
ret = ioctl(STDIN_FILENO, TIOCGWINSZ, &wsz);
if (ret < 0) {
WARN("Failed to get window size");
continue;
}
if (wsz.ws_row == s_pre_wsz.ws_row && wsz.ws_col == s_pre_wsz.ws_col) {
continue;
}
ret = do_resize_exec_console(args, wsz.ws_row, wsz.ws_col);
if (ret != 0) {
continue;
}
s_pre_wsz.ws_row = wsz.ws_row;
s_pre_wsz.ws_col = wsz.ws_col;
}
out:
return NULL;
}
int exec_client_console_resize_thread(struct client_arguments *args)
{
int res = 0;
pthread_t a_thread;
res = pthread_create(&a_thread, NULL, exec_console_resize_thread, (void *)(args));
if (res != 0) {
CRIT("Thread creation failed");
return -1;
}
return 0;
}
int cmd_exec_main(int argc, const char **argv)
{
int ret = 0;
@ -339,6 +456,18 @@ int cmd_exec_main(int argc, const char **argv)
custom_cfg->open_stdin = false;
}
g_cmd_exec_args.exec_suffix = generate_exec_suffix();
if (g_cmd_exec_args.exec_suffix == NULL) {
ERROR("Failed to generate exec suffix");
ret = -1;
goto out;
}
if (custom_cfg->tty && isatty(STDIN_FILENO) && (custom_cfg->attach_stdin || custom_cfg->attach_stdout ||
custom_cfg->attach_stderr)) {
(void)exec_client_console_resize_thread(&g_cmd_exec_args);
}
if (strncmp(g_cmd_exec_args.socket, "tcp://", strlen("tcp://")) == 0) {
ret = remote_cmd_exec(&g_cmd_exec_args, &exit_code);
if (ret != 0) {

128
src/connect/client/grpc/grpc_containers_client.cc
View File

@ -636,6 +636,61 @@ public:
}
};
class ContainerResize : public ClientBase<ContainerService, ContainerService::Stub, lcrc_resize_request, ResizeRequest,
lcrc_resize_response, ResizeResponse> {
public:
explicit ContainerResize(void *args)
: ClientBase(args)
{
}
~ContainerResize() = default;
int request_to_grpc(const lcrc_resize_request *request, ResizeRequest *grequest) override
{
if (request == nullptr) {
return -1;
}
if (request->id != nullptr) {
grequest->set_id(request->id);
}
if (request->suffix != nullptr) {
grequest->set_suffix(request->suffix);
}
grequest->set_height(request->height);
grequest->set_width(request->width);
return 0;
}
int response_from_grpc(ResizeResponse *gresponse, lcrc_resize_response *response) override
{
response->server_errono = gresponse->cc();
if (!gresponse->errmsg().empty()) {
response->errmsg = util_strdup_s(gresponse->errmsg().c_str());
}
return 0;
}
int check_parameter(const ResizeRequest &req) override
{
if (req.id().empty()) {
ERROR("Missing container id in the request");
return -1;
}
return 0;
}
Status grpc_call(ClientContext *context, const ResizeRequest &req, ResizeResponse *reply) override
{
return stub_->Resize(context, req, reply);
}
};
class ContainerRestart : public ClientBase<ContainerService, ContainerService::Stub, lcrc_restart_request,
RestartRequest, lcrc_restart_response, RestartResponse> {
public:
@ -752,6 +807,9 @@ public:
if (request->name != nullptr) {
grequest->set_container_id(request->name);
}
if (request->suffix != nullptr) {
grequest->set_suffix(request->suffix);
}
grequest->set_tty(request->tty);
grequest->set_open_stdin(request->open_stdin);
grequest->set_attach_stdin(request->attach_stdin);
@ -876,6 +934,7 @@ public:
exec.argv_len = (size_t)request->argc;
exec.env = request->env;
exec.env_len = request->env_len;
exec.suffix = request->suffix;
json = container_exec_request_generate_json(&exec, &ctx, &err);
if (json == nullptr) {
format_errorf(&response->errmsg, "Can not generate json: %s", err);
@ -1589,61 +1648,6 @@ cleanup:
}
};
class ContainerConf : public ClientBase<ContainerService, ContainerService::Stub, lcrc_container_conf_request,
Container_conf_Request, lcrc_container_conf_response, Container_conf_Response> {
public:
explicit ContainerConf(void *args)
: ClientBase(args)
{
}
~ContainerConf() = default;
int request_to_grpc(const lcrc_container_conf_request *request, Container_conf_Request *grequest) override
{
if (request == nullptr) {
return -1;
}
if (request->name != nullptr) {
grequest->set_container_id(request->name);
}
return 0;
}
int response_from_grpc(Container_conf_Response *gresponse, lcrc_container_conf_response *response) override
{
response->server_errono = gresponse->cc();
if (!gresponse->errmsg().empty()) {
response->errmsg = util_strdup_s(gresponse->errmsg().c_str());
}
if (!gresponse->container_logpath().empty()) {
response->container_logpath = util_strdup_s(gresponse->container_logpath().c_str());
}
response->container_logrotate = gresponse->container_logrotate();
if (!gresponse->container_logsize().empty()) {
response->container_logsize = util_strdup_s(gresponse->container_logsize().c_str());
}
return 0;
}
int check_parameter(const Container_conf_Request &req) override
{
if (req.container_id().empty()) {
ERROR("Missing container name in the request");
return -1;
}
return 0;
}
Status grpc_call(ClientContext *context, const Container_conf_Request &req, Container_conf_Response *reply) override
{
return stub_->Container_conf(context, req, reply);
}
};
class ContainerStats : public ClientBase<ContainerService, ContainerService::Stub, lcrc_stats_request, StatsRequest,
lcrc_stats_response, StatsResponse> {
public:
@ -1659,10 +1663,6 @@ public:
return -1;
}
if (request->runtime != nullptr) {
grequest->set_runtime(request->runtime);
}
for (size_t i = 0; request->containers != nullptr && i < request->containers_len; i++) {
grequest->add_containers(request->containers[i]);
}
@ -1686,9 +1686,6 @@ public:
if (!gresponse->containers(i).id().empty()) {
response->container_stats[i].id = util_strdup_s(gresponse->containers(i).id().c_str());
}
response->container_stats[i].has_pid = (int)gresponse->containers(i).pid() != -1;
response->container_stats[i].pid = (uint32_t)gresponse->containers(i).pid();
response->container_stats[i].status = (Container_Status)((int)gresponse->containers(i).status());
response->container_stats[i].pids_current = gresponse->containers(i).pids_current();
response->container_stats[i].cpu_use_nanos = gresponse->containers(i).cpu_use_nanos();
response->container_stats[i].cpu_system_use = gresponse->containers(i).cpu_system_use();
@ -1712,11 +1709,6 @@ public:
int check_parameter(const StatsRequest &req) override
{
if (req.runtime().empty()) {
ERROR("Missing runtime in the request");
return -1;
}
return 0;
}
@ -2213,7 +2205,6 @@ int grpc_containers_client_ops_init(lcrc_connect_ops *ops)
ops->container.pause = container_func<lcrc_pause_request, lcrc_pause_response, ContainerPause>;
ops->container.resume = container_func<lcrc_resume_request, lcrc_resume_response, ContainerResume>;
ops->container.update = container_func<lcrc_update_request, lcrc_update_response, ContainerUpdate>;
ops->container.conf = container_func<lcrc_container_conf_request, lcrc_container_conf_response, ContainerConf>;
ops->container.kill = container_func<lcrc_kill_request, lcrc_kill_response, ContainerKill>;
ops->container.stats = container_func<lcrc_stats_request, lcrc_stats_response, ContainerStats>;
ops->container.wait = container_func<lcrc_wait_request, lcrc_wait_response, ContainerWait>;
@ -2226,6 +2217,7 @@ int grpc_containers_client_ops_init(lcrc_connect_ops *ops)
container_func<lcrc_copy_to_container_request, lcrc_copy_to_container_response, CopyToContainer>;
ops->container.top = container_func<lcrc_top_request, lcrc_top_response, ContainerTop>;
ops->container.rename = container_func<lcrc_rename_request, lcrc_rename_response, ContainerRename>;
ops->container.resize = container_func<lcrc_resize_request, lcrc_resize_response, ContainerResize>;
ops->container.logs = container_func<lcrc_logs_request, lcrc_logs_response, ContainerLogs>;
return 0;

6
src/connect/client/lcrc_connect.h
View File

@ -83,9 +83,6 @@ typedef struct {
int(*update)(const struct lcrc_update_request *request,
struct lcrc_update_response *response, void *arg);
int(*conf)(const struct lcrc_container_conf_request *request,
struct lcrc_container_conf_response *response, void *arg);
int(*attach)(const struct lcrc_attach_request *request,
struct lcrc_attach_response *response, void *arg);
@ -98,7 +95,8 @@ typedef struct {
struct lcrc_top_response *response, void *arg);
int(*rename)(const struct lcrc_rename_request *request,
struct lcrc_rename_response *response, void *arg);
int(*resize)(const struct lcrc_resize_request *request,
struct lcrc_resize_response *response, void *arg);
int(*logs)(const struct lcrc_logs_request *request, struct lcrc_logs_response *response, void *arg);
} container_ops;

106
src/connect/client/rest/rest_containers_client.c
View File

@ -271,37 +271,6 @@ out:
return ret;
}
/* container conf request to rest */
static int container_conf_request_to_rest(const struct lcrc_container_conf_request *lconf_request, char **body,
size_t *body_len)
{
container_conf_request *crequest = NULL;
struct parser_context ctx = { OPT_GEN_SIMPLIFY, 0 };
parser_error err = NULL;
int ret = 0;
crequest = util_common_calloc_s(sizeof(container_conf_request));
if (crequest == NULL) {
ERROR("Out of memory");
return -1;
}
if (lconf_request->name != NULL) {
crequest->container_id = util_strdup_s(lconf_request->name);
}
*body = container_conf_request_generate_json(crequest, &ctx, &err);
if (*body == NULL) {
ERROR("Failed to generate conf request json:%s", err);
ret = -1;
goto out;
}
*body_len = strlen(*body) + 1;
out:
free(err);
free_container_conf_request(crequest);
return ret;
}
/* wait request to rest */
static int wait_request_to_rest(const struct lcrc_wait_request *lw_request, char **body, size_t *body_len)
{
@ -568,47 +537,6 @@ out:
return ret;
}
/* unpack container conf response */
static int unpack_container_conf_response(const struct parsed_http_message *message, void *arg)
{
struct lcrc_container_conf_response *response = arg;
container_conf_response *cresponse = NULL;
parser_error err = NULL;
int ret = 0;
ret = check_status_code(message->status_code);
if (ret != 0) {
goto out;
}
cresponse = container_conf_response_parse_data(message->body, NULL, &err);
if (cresponse == NULL) {
ERROR("Invalid create response:%s", err);
ret = -1;
goto out;
}
response->server_errono = cresponse->cc;
if (cresponse->errmsg != NULL) {
response->errmsg = util_strdup_s(cresponse->errmsg);
}
if (cresponse->container_logpath != NULL) {
response->container_logpath = util_strdup_s(cresponse->container_logpath);
}
response->container_logrotate = cresponse->container_logrotate;
if (cresponse->container_logsize != NULL) {
response->container_logsize = util_strdup_s(cresponse->container_logsize);
}
ret = (cresponse->cc == LCRD_SUCCESS) ? 0 : -1;
if (message->status_code == EVHTP_RES_SERVERR) {
ret = -1;
}
out:
free(err);
free_container_conf_response(cresponse);
return ret;
}
/* unpack wait response */
static int unpack_wait_response(const struct parsed_http_message *message, void *arg)
{
@ -811,39 +739,6 @@ out:
return ret;
}
/* rest container conf */
static int rest_container_conf(const struct lcrc_container_conf_request *lc_request,
struct lcrc_container_conf_response *lc_response, void *arg)
{
char *body = NULL;
int ret = 0;
size_t len = 0;
client_connect_config_t *connect_config = (client_connect_config_t *)arg;
const char *socketname = (const char *)(connect_config->socket);
Buffer *c_output = NULL;
ret = container_conf_request_to_rest(lc_request, &body, &len);
if (ret != 0) {
goto out;
}
ret = rest_send_requst(socketname, RestHttpHead ContainerServiceConf, body, len, &c_output);
if (ret != 0) {
lc_response->errmsg = util_strdup_s(errno_to_error_message(LCRD_ERR_CONNECT));
lc_response->cc = LCRD_ERR_EXEC;
goto out;
}
ret = get_response(c_output, unpack_container_conf_response, (void *)lc_response);
if (ret != 0) {
goto out;
}
out:
if (c_output != NULL) {
buffer_free(c_output);
}
put_body(body);
return ret;
}
/* rest container wait */
static int rest_container_wait(const struct lcrc_wait_request *lw_request,
struct lcrc_wait_response *lw_response, void *arg)
@ -1871,7 +1766,6 @@ int rest_containers_client_ops_init(lcrc_connect_ops *ops)
ops->container.attach = &rest_container_attach;
ops->container.resume = &rest_container_resume;
ops->container.update = &rest_container_update;
ops->container.conf = &rest_container_conf;
ops->container.kill = &rest_container_kill;
ops->container.version = &rest_container_version;
ops->container.wait = &rest_container_wait;

71
src/connect/service/grpc/grpc_containers_service.cc
View File

@ -1041,39 +1041,6 @@ Status ContainerServiceImpl::Export(ServerContext *context, const ExportRequest
return Status::OK;
}
Status ContainerServiceImpl::Container_conf(ServerContext *context, const Container_conf_Request *request,
Container_conf_Response *reply)
{
int ret, tret;
service_callback_t *cb = nullptr;
struct lcrd_container_conf_request *lcrdreq = nullptr;
struct lcrd_container_conf_response *lcrdres = nullptr;
cb = get_service_callback();
if (cb == nullptr || cb->container.conf == nullptr) {
return Status(StatusCode::UNIMPLEMENTED, "Unimplemented callback");
}
tret = container_conf_request_from_grpc(request, &lcrdreq);
if (tret != 0) {
ERROR("Failed to transform grpc request");
reply->set_cc(LCRD_ERR_INPUT);
return Status::OK;
}
ret = cb->container.conf(lcrdreq, &lcrdres);
tret = container_conf_response_to_grpc(lcrdres, reply);
lcrd_container_conf_request_free(lcrdreq);
lcrd_container_conf_response_free(lcrdres);
if (tret != 0) {
reply->set_errmsg(errno_to_error_message(LCRD_ERR_INTERNAL));
reply->set_cc(LCRD_ERR_INTERNAL);
ERROR("Failed to translate response to grpc, operation is %s", ret ? "failed" : "success");
}
return Status::OK;
}
Status ContainerServiceImpl::Rename(ServerContext *context, const RenameRequest *request,
RenameResponse *reply)
{
@ -1112,6 +1079,44 @@ Status ContainerServiceImpl::Rename(ServerContext *context, const RenameRequest
return Status::OK;
}
Status ContainerServiceImpl::Resize(ServerContext *context, const ResizeRequest *request,
ResizeResponse *reply)
{
int ret, tret;
service_callback_t *cb = nullptr;
struct lcrd_container_resize_request *lcrdreq = nullptr;
struct lcrd_container_resize_response *lcrdres = nullptr;
auto status = GrpcServerTlsAuth::auth(context, "container_resize");
if (!status.ok()) {
return status;
}
cb = get_service_callback();
if (cb == nullptr || cb->container.resize == nullptr) {
return Status(StatusCode::UNIMPLEMENTED, "Unimplemented callback");
}
tret = container_resize_request_from_grpc(request, &lcrdreq);
if (tret != 0) {
ERROR("Failed to transform grpc request");
reply->set_cc(LCRD_ERR_INPUT);
return Status::OK;
}
ret = cb->container.resize(lcrdreq, &lcrdres);
tret = container_resize_response_to_grpc(lcrdres, reply);
lcrd_container_resize_request_free(lcrdreq);
lcrd_container_resize_response_free(lcrdres);
if (tret != 0) {
reply->set_errmsg(errno_to_error_message(LCRD_ERR_INTERNAL));
reply->set_cc(LCRD_ERR_INTERNAL);
ERROR("Failed to translate response to grpc, operation is %s", ret ? "failed" : "success");
}
return Status::OK;
}
Status ContainerServiceImpl::Update(ServerContext *context, const UpdateRequest *request, UpdateResponse *reply)
{
int ret, tret;

17
src/connect/service/grpc/grpc_containers_service.h
View File

@ -75,11 +75,10 @@ public:
Status Resume(ServerContext *context, const ResumeRequest *request, ResumeResponse *reply) override;
Status Container_conf(ServerContext *context, const Container_conf_Request *request,
Container_conf_Response *reply) override;
Status Rename(ServerContext *context, const RenameRequest *request, RenameResponse *reply) override;
Status Resize(ServerContext *context, const ResizeRequest *request, ResizeResponse *reply) override;
Status Update(ServerContext *context, const UpdateRequest *request, UpdateResponse *reply) override;
@ -165,18 +164,18 @@ private:
int resume_request_from_grpc(const ResumeRequest *grequest, container_resume_request **request);
int container_conf_request_from_grpc(const Container_conf_Request *grequest,
struct lcrd_container_conf_request **request);
int container_conf_response_to_grpc(const struct lcrd_container_conf_response *response,
Container_conf_Response *gresponse);
int container_rename_request_from_grpc(const RenameRequest *grequest,
struct lcrd_container_rename_request **request);
int container_rename_response_to_grpc(const struct lcrd_container_rename_response *response,
RenameResponse *gresponse);
int container_resize_request_from_grpc(const ResizeRequest *grequest,
struct lcrd_container_resize_request **request);
int container_resize_response_to_grpc(const struct lcrd_container_resize_response *response,
ResizeResponse *gresponse);
int update_request_from_grpc(const UpdateRequest *grequest, container_update_request **request);
int update_response_to_grpc(const container_update_response *response, UpdateResponse *gresponse);

98
src/connect/service/grpc/grpc_containers_service_private.cc
View File

@ -352,6 +352,10 @@ int ContainerServiceImpl::exec_request_from_grpc(const ExecRequest *grequest, co
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();
@ -607,46 +611,6 @@ int ContainerServiceImpl::resume_request_from_grpc(const ResumeRequest *grequest
return 0;
}
int ContainerServiceImpl::container_conf_request_from_grpc(const Container_conf_Request *grequest,
struct lcrd_container_conf_request **request)
{
struct lcrd_container_conf_request *tmpreq = (struct lcrd_container_conf_request *)util_common_calloc_s(
sizeof(struct lcrd_container_conf_request));
if (tmpreq == nullptr) {
ERROR("Out of memory");
return -1;
}
if (!grequest->container_id().empty()) {
tmpreq->name = util_strdup_s(grequest->container_id().c_str());
}
*request = tmpreq;
return 0;
}
int ContainerServiceImpl::container_conf_response_to_grpc(const struct lcrd_container_conf_response *response,
Container_conf_Response *gresponse)
{
if (response == nullptr) {
gresponse->set_cc(LCRD_ERR_MEMOUT);
return 0;
}
gresponse->set_cc(response->cc);
if (response->errmsg != nullptr) {
gresponse->set_errmsg(response->errmsg);
}
if (response->container_logpath != nullptr) {
gresponse->set_container_logpath(response->container_logpath);
}
gresponse->set_container_logrotate(response->container_logrotate);
if (response->container_logsize != nullptr) {
gresponse->set_container_logsize(response->container_logsize);
}
return 0;
}
int ContainerServiceImpl::container_rename_request_from_grpc(const RenameRequest *grequest,
struct lcrd_container_rename_request **request)
{
@ -688,6 +652,50 @@ int ContainerServiceImpl::container_rename_response_to_grpc(const struct lcrd_co
return 0;
}
int ContainerServiceImpl::container_resize_request_from_grpc(const ResizeRequest *grequest,
struct lcrd_container_resize_request **request)
{
struct lcrd_container_resize_request *tmpreq = (struct lcrd_container_resize_request *)util_common_calloc_s(
sizeof(struct lcrd_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 lcrd_container_resize_response *response,
ResizeResponse *gresponse)
{
if (response == nullptr) {
gresponse->set_cc(LCRD_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)
{
@ -735,10 +743,6 @@ int ContainerServiceImpl::stats_request_from_grpc(const StatsRequest *grequest,
return -1;
}
if (!grequest->runtime().empty()) {
tmpreq->runtime = util_strdup_s(grequest->runtime().c_str());
}
if (grequest->containers_size() > 0) {
tmpreq->containers = (char **)util_common_calloc_s(grequest->containers_size() * sizeof(char *));
if (tmpreq->containers == nullptr) {
@ -771,12 +775,6 @@ int ContainerServiceImpl::stats_response_to_grpc(const container_stats_response
if (response->container_stats[i]->id != nullptr) {
stats->set_id(response->container_stats[i]->id);
}
if (response->container_stats[i]->has_pid) {
stats->set_pid(response->container_stats[i]->pid);
} else {
stats->set_pid(-1);
}
stats->set_status((ContainerStatus)response->container_stats[i]->status);
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);

120
src/connect/service/rest/rest_containers_service.c
View File

@ -150,20 +150,6 @@ static int list_request_check(void *req)
return ret;
}
/* container conf response check */
static int container_conf_request_check(void *req)
{
int ret = 0;
struct lcrd_container_conf_request *req_conf = (struct lcrd_container_conf_request *)req;
if (req_conf->name == NULL) {
DEBUG("container name error");
ret = -1;
goto out;
}
out:
return ret;
}
/* create request check */
static int create_request_check(void *req)
{
@ -297,11 +283,6 @@ static struct rest_handle_st g_rest_handle[] = {
.request_parse_data = (void *)container_wait_request_parse_data,
.request_check = wait_request_check,
},
{
.name = ContainerServiceConf,
.request_parse_data = (void *)container_conf_request_parse_data,
.request_check = container_conf_request_check,
},
{
.name = ContainerServiceInspect,
.request_parse_data = (void *)container_inspect_request_parse_data,
@ -411,50 +392,6 @@ out:
return;
}
/* evhtp send container conf repsponse */
static void evhtp_send_container_conf_repsponse(evhtp_request_t *req, container_conf_response *response, int rescode)
{
parser_error err = NULL;
struct parser_context ctx = { OPT_GEN_SIMPLIFY, 0 };
char *responsedata = NULL;
responsedata = container_conf_response_generate_json(response, &ctx, &err);
if (responsedata == NULL) {
ERROR("Failed to generate container_conf request json:%s", err);
evhtp_send_reply(req, EVHTP_RES_ERROR);
goto out;
}
evhtp_send_response(req, responsedata, rescode);
out:
free(err);
free(responsedata);
return;
}
/* container conf response to rest */
static int container_conf_response_to_rest(container_conf_response *cresponse,
struct lcrd_container_conf_response *response)
{
if (response == NULL) {
cresponse->cc = LCRD_ERR_MEMOUT;
return 0;
}
cresponse->cc = response->cc;
if (response->errmsg) {
cresponse->errmsg = util_strdup_s(response->errmsg);
}
if (response->container_logpath) {
cresponse->container_logpath = util_strdup_s(response->container_logpath);
}
cresponse->container_logrotate = response->container_logrotate;
if (response->container_logsize) {
cresponse->container_logsize = util_strdup_s(response->container_logsize);
}
return 0;
}
/* evhtp send wait repsponse */
static void evhtp_send_wait_repsponse(evhtp_request_t *req, container_wait_response *response, int rescode)
{
@ -547,58 +484,6 @@ out:
free_container_start_response(cresponse);
}
/* rest container conf cb */
static void rest_container_conf_cb(evhtp_request_t *req, void *arg)
{
int ret, tret;
service_callback_t *cb = NULL;
struct lcrd_container_conf_request *lcrdreq = NULL;
struct lcrd_container_conf_response *lcrdres = NULL;
container_conf_response *cresponse = NULL;
// only deal with POST request
if (evhtp_request_get_method(req) != htp_method_POST) {
evhtp_send_reply(req, EVHTP_RES_NOTIMPL);
return;
}
cb = get_service_callback();
if (cb == NULL || cb->container.conf == NULL) {
ERROR("Unimplemented callback");
evhtp_send_reply(req, EVHTP_RES_NOTIMPL);
return;
}
cresponse = util_common_calloc_s(sizeof(container_conf_response));
if (cresponse == NULL) {
evhtp_send_reply(req, EVHTP_RES_ERROR);
return;
}
tret = action_request_from_rest(req, (void **)&lcrdreq, ContainerServiceConf);
if (tret < 0) {
ERROR("Bad request");
cresponse->cc = LCRD_ERR_EXEC;
evhtp_send_container_conf_repsponse(req, cresponse, EVHTP_RES_SERVERR);
goto out;
}
ret = cb->container.conf(lcrdreq, &lcrdres);
tret = container_conf_response_to_rest(cresponse, lcrdres);
if (tret) {
ERROR("Failed to translate response to rest,operation is %s", ret ? "failed" : "success");
cresponse->cc = LCRD_ERR_EXEC;
if (cresponse->errmsg == NULL) {
cresponse->errmsg = util_strdup_s(errno_to_error_message(LCRD_ERR_INTERNAL));
}
}
evhtp_send_container_conf_repsponse(req, cresponse, EVHTP_RES_OK);
out:
lcrd_container_conf_request_free(lcrdreq);
lcrd_container_conf_response_free(lcrdres);
free_container_conf_response(cresponse);
}
/* rest wait cb */
static void rest_wait_cb(evhtp_request_t *req, void *arg)
{
@ -1213,11 +1098,6 @@ int rest_register_containers_handler(evhtp_t *htp)
return -1;
}
if (evhtp_set_cb(htp, ContainerServiceConf, rest_container_conf_cb, NULL) == NULL) {
ERROR("Failed to register container_conf callback");
return -1;
}
if (evhtp_set_cb(htp, ContainerServiceWait, rest_wait_cb, NULL) == NULL) {
ERROR("Failed to register wait callback");
return -1;

50
src/cutils/utils.c
View File

@ -1424,4 +1424,54 @@ void usleep_nointerupt(unsigned long usec)
request = remain;
} while (ret == -1 && errno == EINTR);
}
int util_generate_random_str(char *id, size_t len)
{
int fd = -1;
int num = 0;
size_t i;
const int m = 256;
len = len / 2;
fd = open("/dev/urandom", O_RDONLY);
if (fd == -1) {
ERROR("Failed to open /dev/urandom");
return -1;
}
for (i = 0; i < len; i++) {
int nret;
if (read(fd, &num, sizeof(int)) < 0) {
ERROR("Failed to read urandom value");
close(fd);
return -1;
}
unsigned char rs = (unsigned char)(num % m);
nret = snprintf((id + i * 2), ((len - i) * 2 + 1), "%02x", (unsigned int)rs);
if (nret < 0 || (size_t)nret >= ((len - i) * 2 + 1)) {
ERROR("Failed to snprintf random string");
close(fd);
return -1;
}
}
close(fd);
id[i * 2] = '\0';
return 0;
}
void add_array_elem(char **array, size_t total, size_t *pos, const char *elem)
{
if (*pos + 1 >= total - 1) {
return;
}
array[*pos] = util_strdup_s(elem);
*pos += 1;
}
void add_array_kv(char **array, size_t total, size_t *pos, const char *k, const char *v)
{
if (k == NULL || v == NULL) {
return;
}
add_array_elem(array, total, pos, k);
add_array_elem(array, total, pos, v);
}

10
src/cutils/utils.h
View File

@ -57,6 +57,8 @@ extern "C" {
#define ECOMMON 1
#define PARAM_NUM 100
/* image error start */
#define EIMAGEBUSY 2
#define ENAMECONFLICT 3
@ -90,6 +92,8 @@ extern "C" {
/* container id max length */
#define CONTAINER_ID_MAX_LEN 64
#define CONTAINER_EXEC_ID_MAX_LEN 64
#define LIST_SIZE_MAX 1000LL
#define LIST_DEVICE_SIZE_MAX 10000LL
#define LIST_ENV_SIZE_MAX 200000LL
@ -418,6 +422,12 @@ bool util_check_signal_valid(int sig);
void usleep_nointerupt(unsigned long usec);
int util_generate_random_str(char *id, size_t len);
void add_array_elem(char **array, size_t total, size_t *pos, const char *elem);
void add_array_kv(char **array, size_t total, size_t *pos, const char *k, const char *v);
#ifdef __cplusplus
}
#endif

10
src/cutils/utils_regex.c
View File

@ -95,15 +95,15 @@ int util_wildcard_to_regex(const char *wildcard, char **regex)
size_t index = 0;
size_t regex_size;
char escapes[] = { '$', '^', '[', ']', '(', ')', '{', '|', '+', '\\', '.', '<', '>', '}' };
if (wildcard == NULL) {
return 0;
}
if (wildcard == NULL || regex == NULL) {
ERROR("Invalid output parameter");
return -1;
}
if (get_regex_size_from_wildcard(wildcard, escapes, sizeof(escapes) / sizeof(char), &regex_size) != 0) {
return -1;
}
*regex = malloc(regex_size);
*regex = (char *)util_common_calloc_s(regex_size);
if (*regex == NULL) {
ERROR("Out of memory");
return -1;

11
src/cutils/utils_verify.c
View File

@ -622,3 +622,14 @@ cleanup:
return bret;
}
bool util_valid_exec_suffix(const char *suffix)
{
char *patten = "^[a-f0-9]{64}$";
if (suffix == NULL) {
ERROR("invalid NULL param");
return false;
}
return util_reg_match(patten, suffix) == 0;
}

2
src/cutils/utils_verify.h
View File

@ -96,6 +96,8 @@ bool util_valid_runtime_name(const char *name);
bool util_valid_short_sha256_id(const char *id);
bool util_valid_exec_suffix(const char *suffix);
#ifdef __cplusplus
}
#endif

44
src/engines/engine.h
View File

@ -23,12 +23,6 @@
extern "C" {
#endif
struct engine_console_config {
char *log_path;
unsigned int log_rotate;
char *log_file_size;
};
struct engine_cgroup_resources {
uint64_t blkio_weight;
uint64_t cpu_shares;
@ -66,11 +60,13 @@ struct engine_container_summary_info {
char *finishat;
};
struct engine_container_info {
char *id;
struct engine_container_status_info {
bool has_pid;
uint32_t pid;
Engine_Container_Status status;
};
struct engine_container_resources_stats_info {
uint64_t pids_current;
/* CPU usage */
uint64_t cpu_use_nanos;
@ -131,6 +127,8 @@ typedef struct _engine_exec_request_t {
size_t args_len;
int64_t timeout;
const char *suffix;
} engine_exec_request_t;
@ -149,33 +147,25 @@ typedef bool (*engine_resume_t)(const char *name, const char *enginepath);
typedef bool (*engine_reset_t)(const char *name, const char *enginepath);
typedef bool (*engine_resize_t)(const char *name, const char *lcrpath, unsigned int height, unsigned int width);
typedef bool (*engine_exec_resize_t)(const char *name, const char *lcrpath, const char *suffix, unsigned int height,
unsigned int width);
typedef bool (*engine_update_t)(const char *name, const char *enginepath, const struct engine_cgroup_resources *cr);
typedef bool (*engine_exec_t)(const engine_exec_request_t *request, int *exit_code);
typedef int (*engine_get_all_containers_info_t)(const char *enginepath, struct engine_container_summary_info **cons);
typedef struct engine_container_summary_info *(*engine_get_container_info_t)(const char *name, const char *enginepath);
typedef void (*engine_free_container_info_t)(struct engine_container_summary_info *info);
typedef void (*engine_free_all_containers_info_t)(struct engine_container_summary_info *info, int num);
typedef int (*engine_get_container_status_t)(const char *name, const char *enginepath,
struct engine_container_info *status);
struct engine_container_status_info *status);
typedef void (*engine_free_container_status_t)(struct engine_container_info *container);
typedef int (*engine_get_container_resources_stats_t)(const char *name, const char *enginepath,
struct engine_container_resources_stats_info *rs_stats);
typedef bool (*engine_get_container_pids_t)(const char *name, const char *rootpath, pid_t **pids, size_t *pids_len);
typedef bool (*engine_console_t)(const char *name, const char *enginepath, char *in_fifo, char *out_fifo,
char *err_fifo);
typedef bool (*engine_get_console_config_t)(const char *name, const char *enginepath,
struct engine_console_config *config);
typedef void (*engine_free_console_config_t)(struct engine_console_config *config);
typedef int (*engine_log_init_t)(const char *name, const char *file, const char *priority, const char *prefix,
int quiet, const char *enginepath);
@ -193,17 +183,15 @@ struct engine_operation {
engine_pause_t engine_pause_op;
engine_resume_t engine_resume_op;
engine_reset_t engine_reset_op;
engine_resize_t engine_resize_op;
engine_exec_resize_t engine_exec_resize_op;
engine_exec_t engine_exec_op;
engine_console_t engine_console_op;
engine_get_container_status_t engine_get_container_status_op;
engine_free_container_status_t engine_free_container_status_op;
engine_get_all_containers_info_t engine_get_all_containers_info_op;
engine_free_all_containers_info_t engine_free_all_containers_info_op;
engine_get_container_resources_stats_t engine_get_container_resources_stats_op;
engine_get_container_pids_t engine_get_container_pids_op;
engine_log_init_t engine_log_init_op;
engine_update_t engine_update_op;
engine_get_console_config_t engine_get_console_config_op;
engine_free_console_config_t engine_free_console_config_op;
engine_get_errmsg_t engine_get_errmsg_op;
engine_clear_errmsg_t engine_clear_errmsg_op;
engine_clean_t engine_clean_op;

266
src/engines/lcr/lcr_engine.c
View File

@ -27,23 +27,15 @@
#include "log.h"
#include "lcrd_config.h"
typedef int(*lcr_list_all_containers_t)(const char *lcrpath, struct lcr_container_info **info_arr);
typedef void(*lcr_containers_info_free_t)(struct lcr_container_info **info_arr, size_t size);
typedef bool(*lcr_state_op_t)(const char *name, const char *lcrpath, struct lcr_container_state *lcs);
typedef void(*lcr_container_state_free_t)(struct lcr_container_state *lcs);
typedef bool(*lcr_update_op_t)(const char *name, const char *lcrpath, struct lcr_cgroup_resources *cr);
typedef bool(*lcr_get_console_config_op_t)(const char *name, const char *lcrpath, struct lcr_console_config *config);
typedef void(*lcr_free_console_config_op_t)(struct lcr_console_config *config);
typedef bool(*lcr_start_op_t)(struct lcr_start_request *request);
typedef bool(*lcr_exec_op_t)(const struct lcr_exec_request *request, int *exit_code);
static lcr_list_all_containers_t g_lcr_list_all_containers_op = NULL;
static lcr_containers_info_free_t g_lcr_containers_info_free_op = NULL;
static lcr_state_op_t g_lcr_state_op = NULL;
static lcr_container_state_free_t g_lcr_container_state_free_op = NULL;
static lcr_update_op_t g_lcr_update_op = NULL;
static lcr_get_console_config_op_t g_lcr_get_console_config_op = NULL;
static lcr_free_console_config_op_t g_lcr_free_console_config_op = NULL;
static lcr_start_op_t g_lcr_start_op = NULL;
static lcr_exec_op_t g_lcr_exec_op = NULL;
/*
@ -120,199 +112,21 @@ static bool lcr_exec_container(const engine_exec_request_t *request, int *exit_c
return g_lcr_exec_op(lcr_request, exit_code);
}
/* free console config */
void free_console_config(struct engine_console_config *config)
{
if (config == NULL) {
return;
}
free(config->log_path);
config->log_path = NULL;
free(config->log_file_size);
config->log_file_size = NULL;
config->log_rotate = 0;
}
/* get console config */
bool get_console_config(const char *name, const char *lcrpath, struct engine_console_config *config)
{
struct lcr_console_config lcr_config;
bool ret = false;
if (name == NULL || config == NULL) {
ERROR("Invalid arguments");
return ret;
}
(void)memset(&lcr_config, 0, sizeof(struct lcr_console_config));
if (g_lcr_get_console_config_op != NULL) {
ret = g_lcr_get_console_config_op(name, lcrpath, &lcr_config);
}
if (ret) {
if (lcr_config.log_path) {
config->log_path = util_strdup_s(lcr_config.log_path);
} else {
config->log_path = NULL;
}
config->log_rotate = lcr_config.log_rotate;
if (lcr_config.log_file_size) {
config->log_file_size = util_strdup_s(lcr_config.log_file_size);
} else {
config->log_file_size = NULL;
}
if (g_lcr_free_console_config_op != NULL) {
g_lcr_free_console_config_op(&lcr_config);
}
}
return ret;
}
/*
* Get the containers info by liblcr
*/
static void get_containers_info(int num, const struct lcr_container_info *info_arr,
struct engine_container_summary_info *info)
{
int i = 0;
const struct lcr_container_info *in = NULL;
char *name = NULL;
for (i = 0, in = info_arr; i < num; i++, in++) {
name = in->name;
if (name == NULL) {
continue;
}
info[i].id = util_strdup_s(name);
info[i].has_pid = (-1 == in->init) ? false : true;
info[i].pid = (uint32_t)in->init;
info[i].status = lcrsta2sta(in->state);
}
}
/*
* Get the state of container from 'lcr_container_state'
*/
static void copy_container_status(const struct lcr_container_state *lcs, struct engine_container_info *status)
static void copy_container_status(const struct lcr_container_state *lcs, struct engine_container_status_info *status)
{
const char *defvalue = "-";
const char *name = NULL;
(void)memset(status, 0, sizeof(struct engine_container_info));
name = lcs->name ? lcs->name : defvalue;
status->id = util_strdup_s(name);
(void)memset(status, 0, sizeof(struct engine_container_status_info));
status->has_pid = (-1 == lcs->init) ? false : true;
status->pid = (uint32_t)lcs->init;
status->status = lcrsta2sta(lcs->state);
status->pids_current = lcs->pids_current;
status->cpu_use_nanos = lcs->cpu_use_nanos;
status->blkio_read = lcs->io_service_bytes.read;
status->blkio_write = lcs->io_service_bytes.write;
status->mem_used = lcs->mem_used;
status->mem_limit = lcs->mem_limit;
status->kmem_used = lcs->kmem_used;
status->kmem_limit = lcs->kmem_limit;
}
/*
* Alloc Memory for containerArray and container
*/
static int service_list_alloc(int num, struct engine_container_summary_info **cons)
{
if (num <= 0 || cons == NULL) {
return -1;
}
if ((size_t)num > SIZE_MAX / sizeof(struct engine_container_summary_info)) {
ERROR("Too many engine container summaries!");
return -1;
}
*cons = util_common_calloc_s((size_t)num * sizeof(struct engine_container_summary_info));
if ((*cons) == NULL) {
ERROR("Out of memory");
return -1;
}
return 0;
}
/*
* Free the container** containerArray
*/
static void free_all_containers_info(struct engine_container_summary_info *info, int num)
{
int i = 0;
if (num <= 0 || info == NULL) {
return;
}
for (i = 0; i < num; i++) {
free(info[i].id);
info[i].id = NULL;
free(info[i].command);
info[i].command = NULL;
free(info[i].image);
info[i].image = NULL;
free(info[i].finishat);
info[i].finishat = NULL;
free(info[i].startat);
info[i].startat = NULL;
}
free(info);
}
/* get all containers info */
static int get_all_containers_info(const char *enginepath, struct engine_container_summary_info **cons)
{
struct lcr_container_info *info_arr = NULL;
int num = 0;
if (cons == NULL) {
ERROR("Invalid argument");
return -1;
}
if (g_lcr_list_all_containers_op == NULL || g_lcr_containers_info_free_op == NULL) {
ERROR("Not supported op");
num = -1;
goto free_out;
}
num = g_lcr_list_all_containers_op(enginepath, &info_arr);
if (num <= 0) {
num = 0; /* set to 0 if non were found */
goto free_out;
}
if (service_list_alloc(num, cons)) {
g_lcr_containers_info_free_op(&info_arr, (size_t)num);
ERROR("service list alloc failed");
num = -1;
goto free_out;
}
get_containers_info(num, info_arr, *cons);
g_lcr_containers_info_free_op(&info_arr, (size_t)num);
free_out:
return num;
}
/* get container status */
static int get_container_status(const char *name, const char *enginepath, struct engine_container_info *status)
static int get_container_status(const char *name, const char *enginepath, struct engine_container_status_info *status)
{
struct lcr_container_state lcs = { 0 };
@ -331,22 +145,43 @@ static int get_container_status(const char *name, const char *enginepath, struct
return 0;
}
/* free container status */
static void free_container_status(struct engine_container_info *status)
static void copy_container_resources_stats(const struct lcr_container_state *lcs,
struct engine_container_resources_stats_info *rs_stats)
{
if (status == NULL) {
return;
(void)memset(rs_stats, 0, sizeof(struct engine_container_resources_stats_info));
rs_stats->pids_current = lcs->pids_current;
rs_stats->cpu_use_nanos = lcs->cpu_use_nanos;
rs_stats->blkio_read = lcs->io_service_bytes.read;
rs_stats->blkio_write = lcs->io_service_bytes.write;
rs_stats->mem_used = lcs->mem_used;
rs_stats->mem_limit = lcs->mem_limit;
rs_stats->kmem_used = lcs->kmem_used;
rs_stats->kmem_limit = lcs->kmem_limit;
}
free(status->id);
status->id = NULL;
/* get container cgroup resources */
static int lcr_get_container_resources_stats(const char *name, const char *enginepath,
struct engine_container_resources_stats_info *rs_stats)
{
struct lcr_container_state lcs = { 0 };
if (g_lcr_state_op == NULL || g_lcr_container_state_free_op == NULL) {
ERROR("Not supported op");
return -1;
}
#define CHECK_ERROR(P) do { \
if (dlerror() != NULL) { \
goto badcleanup; \
} \
} while (0)
if (!g_lcr_state_op(name, enginepath, &lcs)) {
DEBUG("Failed to state for container '%s'", name);
g_lcr_container_state_free_op(&lcs);
return -1;
}
copy_container_resources_stats(&lcs, rs_stats);
g_lcr_container_state_free_op(&lcs);
return 0;
}
static bool load_lcr_exec_ops(void *lcr_handler, struct engine_operation *eop)
{
@ -386,6 +221,14 @@ static bool load_lcr_exec_ops(void *lcr_handler, struct engine_operation *eop)
if (dlerror() != NULL) {
return false;
}
eop->engine_resize_op = dlsym(lcr_handler, "lcr_resize");
if (dlerror() != NULL) {
return false;
}
eop->engine_exec_resize_op = dlsym(lcr_handler, "lcr_exec_resize");
if (dlerror() != NULL) {
return false;
}
return true;
}
@ -403,22 +246,6 @@ static bool load_lcr_info_ops(void *lcr_handler, struct engine_operation *eop)
if (dlerror() != NULL) {
return false;
}
g_lcr_get_console_config_op = dlsym(lcr_handler, "lcr_get_console_config");
if (dlerror() != NULL) {
return false;
}
g_lcr_free_console_config_op = dlsym(lcr_handler, "lcr_free_console_config");
if (dlerror() != NULL) {
return false;
}
g_lcr_list_all_containers_op = dlsym(lcr_handler, "lcr_list_all_containers");
if (dlerror() != NULL) {
return false;
}
g_lcr_containers_info_free_op = dlsym(lcr_handler, "lcr_containers_info_free");
if (dlerror() != NULL) {
return false;
}
g_lcr_state_op = dlsym(lcr_handler, "lcr_state");
if (dlerror() != NULL) {
return false;
@ -464,16 +291,11 @@ struct engine_operation *lcr_engine_init()
ERROR("Load lcr info operations failed");
goto badcleanup;
}
eop->engine_get_all_containers_info_op = get_all_containers_info;
eop->engine_free_all_containers_info_op = free_all_containers_info;
eop->engine_get_container_status_op = get_container_status;
eop->engine_free_container_status_op = free_container_status;
eop->engine_get_container_resources_stats_op = lcr_get_container_resources_stats;
eop->engine_update_op = lcr_update_container;
eop->engine_start_op = lcr_start_container;
eop->engine_exec_op = lcr_exec_container;
eop->engine_get_console_config_op = get_console_config;
eop->engine_free_console_config_op = free_console_config;
goto cleanup;

21
src/image/oci/global_config.h
View File

@ -21,8 +21,6 @@
extern "C" {
#endif
#define PARAM_NUM 100
enum {
GB_OPTION_GRAPH_ROOT = 0,
GB_OPTION_RUN_ROOT,
@ -37,25 +35,6 @@ enum {
GB_OPTION_MAX, // should not be used
};
static inline void add_array_elem(char **array, size_t total, size_t *pos, const char *elem)
{
if (*pos + 1 >= total - 1) {
return;
}
array[*pos] = util_strdup_s(elem);
*pos += 1;
}
static inline void add_array_kv(char **array, size_t total, size_t *pos, const char *k, const char *v)
{
if (k == NULL || v == NULL) {
return;
}
add_array_elem(array, total, pos, k);
add_array_elem(array, total, pos, v);
}
int pack_global_options(const char * const *options, char *params[], size_t *count, bool ignore_storage_opt_size);
#ifdef __cplusplus

6
src/image/oci/isula_image.c
View File

@ -61,11 +61,15 @@ void isula_exit(void)
static int start_isula_image_server(void)
{
#define MIN_OPT_TIMEOUT 15
struct server_monitor_conf sm_conf = { 0 };
struct timespec ts = { 0 };
sem_t wait_monitor_sem;
unsigned int im_opt_timeout = conf_get_im_opt_timeout();
int ret = 0;
im_opt_timeout = im_opt_timeout >= MIN_OPT_TIMEOUT ? im_opt_timeout : MIN_OPT_TIMEOUT;
// check whether isula_kit is running by systemd
if (util_file_exists(ISULA_IMAGE_SERVER_DEFAULT_SOCK)) {
if (!conf_update_im_server_sock_addr(ISULA_IMAGE_SERVER_DEFAULT_SOCK)) {
@ -93,7 +97,7 @@ static int start_isula_image_server(void)
ret = -1;
goto out;
}
ts.tv_sec += 15; // set deadline 15s
ts.tv_sec += (time_t)im_opt_timeout; // set deadline
ret = sem_timedwait(&wait_monitor_sem, &ts);
if (ret != 0) {

38
src/image/oci/run_image_server.c
View File

@ -245,10 +245,42 @@ static void *heartbeat_for_isulad_kit(void *arg)
return NULL;
}
static unsigned long get_timeout_secs(bool retry)
{
unsigned long result = RETRY_COUNT_MAX;
if (retry) {
return result;
}
result = conf_get_im_opt_timeout();
if (result < RETRY_COUNT_MAX) {
result = RETRY_COUNT_MAX;
}
return result;
}
static bool is_timeout(unsigned long max_second, unsigned long retry_cnt)
{
unsigned long total = retry_cnt;
if (total >= ULONG_MAX / (total + 1)) {
return true;
}
total = total * (total + 1) / 2;
// time unit is second, retry time is 0.1s
if (total >= max_second * 10) {
return true;
}
return false;
}
static int isula_image_server_load_first_check(const struct server_monitor_conf *conf, bool retry)
{
int ret = 0;
unsigned long retry_cnt = 1;
unsigned long retry_cnt = 0;
unsigned long opt_timeout = get_timeout_secs(retry);
/* parent: check server is running */
while (true) {
@ -257,13 +289,13 @@ static int isula_image_server_load_first_check(const struct server_monitor_conf
if (ret == 0) {
break;
}
retry_cnt++;
if (retry_cnt > RETRY_COUNT_MAX) {
if (is_timeout(opt_timeout, retry_cnt)) {
// don't post sem to main thread
ERROR("First load image server failed");
ret = -1;
goto out;
}
retry_cnt++;
}
/* 1. If health check success, send a mutex to main thread and make it run again;

3
src/json/schema/schema/container/exec-request.json
View File

@ -5,6 +5,9 @@
"container_id": {
"type": "string"
},
"suffix": {
"type": "string"
},
"tty": {
"type": "boolean"
},

81
src/liblcrc.c
View File

@ -648,6 +648,9 @@ void lcrc_exec_request_free(struct lcrc_exec_request *request)
free(request->name);
request->name = NULL;
free(request->suffix);
request->suffix = NULL;
free(request->stdout);
request->stdout = NULL;
@ -778,38 +781,6 @@ void lcrc_resume_response_free(struct lcrc_resume_response *response)
free(response);
}
/* lcrc container conf request free */
void lcrc_container_conf_request_free(struct lcrc_container_conf_request *req)
{
if (req == NULL) {
return;
}
free(req->name);
req->name = NULL;
free(req);
}
/* lcrc container conf response free */
void lcrc_container_conf_response_free(struct lcrc_container_conf_response *resp)
{
if (resp == NULL) {
return;
}
free(resp->errmsg);
resp->errmsg = NULL;
free(resp->container_logpath);
resp->container_logpath = NULL;
free(resp->container_logsize);
resp->container_logsize = NULL;
free(resp);
}
/* lcrc kill request free */
void lcrc_kill_request_free(struct lcrc_kill_request *request)
{
@ -882,12 +853,20 @@ void lcrc_update_response_free(struct lcrc_update_response *response)
/* lcrc stats request free */
void lcrc_stats_request_free(struct lcrc_stats_request *request)
{
size_t i = 0;
if (request == NULL) {
return;
}
free(request->runtime);
request->runtime = NULL;
for (i = 0; i < request->containers_len; i++) {
free(request->containers[i]);
request->containers[i] = NULL;
}
free(request->containers);
request->containers = NULL;
free(request);
}
@ -902,8 +881,8 @@ void lcrc_stats_response_free(struct lcrc_stats_response *response)
response->errmsg = NULL;
if (response->container_stats != NULL && response->container_num) {
int i;
for (i = 0; i < (int)response->container_num; i++) {
size_t i;
for (i = 0; i < response->container_num; i++) {
free(response->container_stats[i].id);
response->container_stats[i].id = NULL;
}
@ -1348,6 +1327,36 @@ void lcrc_rename_response_free(struct lcrc_rename_response *response)
free(response);
}
/* lcrc resize request free */
void lcrc_resize_request_free(struct lcrc_resize_request *request)
{
if (request == NULL) {
return;
}
free(request->id);
request->id = NULL;
free(request->suffix);
request->suffix = NULL;
free(request);
}
/* lcrc resize response free */
void lcrc_resize_response_free(struct lcrc_resize_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
/* lcrc logs request free */
void lcrc_logs_request_free(struct lcrc_logs_request *request)
{

39
src/liblcrc.h
View File

@ -296,9 +296,6 @@ struct lcrc_resume_response {
struct lcrc_container_info {
char *id;
bool has_pid;
uint32_t pid;
Container_Status status;
uint64_t pids_current;
// CPU usage
uint64_t cpu_use_nanos;
@ -359,7 +356,6 @@ struct lcrc_list_response {
};
struct lcrc_stats_request {
char *runtime;
char **containers;
size_t containers_len;
bool all;
@ -449,6 +445,7 @@ struct lcrc_wait_response {
struct lcrc_exec_request {
char *name;
char *suffix;
bool tty;
bool open_stdin;
bool attach_stdin;
@ -542,19 +539,6 @@ struct lcrc_info_response {
char *errmsg;
};
struct lcrc_container_conf_request {
char *name;
};
struct lcrc_container_conf_response {
uint32_t cc;
uint32_t server_errono;
char *container_logpath;
uint32_t container_logrotate;
char *container_logsize;
char *errmsg;
};
typedef struct lcrc_update_config {
char *restart_policy;
container_cgroup_resources_t *cr;
@ -688,6 +672,19 @@ struct lcrc_rename_response {
char *errmsg;
};
struct lcrc_resize_request {
char *id;
char *suffix;
uint32_t height;
uint32_t width;
};
struct lcrc_resize_response {
uint32_t cc;
uint32_t server_errono;
char *errmsg;
};
Container_Status lcrcstastr2sta(const char *state);
struct lcrc_filters *lcrc_filters_parse_args(const char **array, size_t len);
@ -758,10 +755,6 @@ void lcrc_resume_request_free(struct lcrc_resume_request *request);
void lcrc_resume_response_free(struct lcrc_resume_response *response);
void lcrc_container_conf_request_free(struct lcrc_container_conf_request *req);
void lcrc_container_conf_response_free(struct lcrc_container_conf_response *resp);
void lcrc_kill_request_free(struct lcrc_kill_request *request);
void lcrc_kill_response_free(struct lcrc_kill_response *response);
@ -833,6 +826,10 @@ void lcrc_rename_request_free(struct lcrc_rename_request *request);
void lcrc_rename_response_free(struct lcrc_rename_response *response);
void lcrc_resize_request_free(struct lcrc_resize_request *request);
void lcrc_resize_response_free(struct lcrc_resize_response *response);
void lcrc_logs_request_free(struct lcrc_logs_request *request);
void lcrc_logs_response_free(struct lcrc_logs_response *response);

62
src/liblcrd.c
View File

@ -26,36 +26,6 @@
// record the errno
__thread char *g_lcrd_errmsg = NULL;
/* lcrd container conf request free */
void lcrd_container_conf_request_free(struct lcrd_container_conf_request *request)
{
if (request == NULL) {
return;
}
free(request->name);
request->name = NULL;
free(request);
}
/* lcrd container conf response free */
void lcrd_container_conf_response_free(struct lcrd_container_conf_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response->container_logpath);
response->container_logpath = NULL;
free(response->container_logsize);
response->container_logsize = NULL;
free(response);
}
/* lcrd events request free */
void lcrd_events_request_free(struct lcrd_events_request *request)
{
@ -193,6 +163,38 @@ void lcrd_container_rename_response_free(struct lcrd_container_rename_response *
free(response);
}
/* lcrd container rename request free */
void lcrd_container_resize_request_free(struct lcrd_container_resize_request *request)
{
if (request == NULL) {
return;
}
free(request->id);
request->id = NULL;
free(request->suffix);
request->suffix = NULL;
free(request);
}
/* lcrd container rename response free */
void lcrd_container_resize_response_free(struct lcrd_container_resize_response *response)
{
if (response == NULL) {
return;
}
free(response->id);
response->id = NULL;
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
void lcrd_logs_request_free(struct lcrd_logs_request *request)
{
if (request == NULL) {

34
src/liblcrd.h
View File

@ -243,19 +243,6 @@ struct lcrd_health_check_response {
char *errmsg;
};
struct lcrd_container_conf_request {
char *name;
};
struct lcrd_container_conf_response {
uint32_t cc;
uint32_t server_errono;
char *container_logpath;
uint32_t container_logrotate;
char *container_logsize;
char *errmsg;
};
struct lcrd_container_rename_request {
char *old_name;
char *new_name;
@ -267,6 +254,19 @@ struct lcrd_container_rename_response {
char *errmsg;
};
struct lcrd_container_resize_request {
char *id;
char *suffix;
uint32_t height;
uint32_t width;
};
struct lcrd_container_resize_response {
char *id;
uint32_t cc;
char *errmsg;
};
struct lcrd_image_info {
char *imageref;
@ -295,10 +295,6 @@ struct container_log_config {
};
void container_log_config_free(struct container_log_config *conf);
void lcrd_container_conf_request_free(struct lcrd_container_conf_request *request);
void lcrd_container_conf_response_free(struct lcrd_container_conf_response *response);
void lcrd_events_request_free(struct lcrd_events_request *request);
void lcrd_copy_from_container_request_free(struct lcrd_copy_from_container_request *request);
@ -315,6 +311,10 @@ void lcrd_container_rename_request_free(struct lcrd_container_rename_request *re
void lcrd_container_rename_response_free(struct lcrd_container_rename_response *response);
void lcrd_container_resize_request_free(struct lcrd_container_resize_request *request);
void lcrd_container_resize_response_free(struct lcrd_container_resize_response *response);
void lcrd_logs_request_free(struct lcrd_logs_request *request);
void lcrd_logs_response_free(struct lcrd_logs_response *response);
#ifdef __cplusplus

248
src/runtime/lcr/lcr_rt_ops.c
View File

@ -62,12 +62,14 @@ int rt_lcr_create(const char *name, const char *runtime, const rt_create_params_
lcrd_set_error_message("Create container error: %s",
(tmpmsg && strcmp(tmpmsg, DEF_SUCCESS_STR)) ? tmpmsg
: DEF_ERR_RUNTIME_STR);
engine_ops->engine_clear_errmsg_op();
ret = -1;
goto out;
}
out:
if (engine_ops != NULL) {
engine_ops->engine_clear_errmsg_op();
}
free(runtime_root);
return ret;
}
@ -138,7 +140,6 @@ int rt_lcr_start(const char *name, const char *runtime, const rt_start_params_t
: DEF_ERR_RUNTIME_STR);
ERROR("Start container error: %s", (tmpmsg && strcmp(tmpmsg, DEF_SUCCESS_STR)) ? tmpmsg
: DEF_ERR_RUNTIME_STR);
engine_ops->engine_clear_errmsg_op();
ret = -1;
goto out;
}
@ -149,6 +150,9 @@ int rt_lcr_start(const char *name, const char *runtime, const rt_start_params_t
goto out;
}
out:
if (engine_ops != NULL) {
engine_ops->engine_clear_errmsg_op();
}
return ret;
}
@ -247,38 +251,8 @@ out:
return ret;
}
int rt_lcr_get_console_config(const char *name, const char *runtime, const rt_get_console_conf_params_t *params)
{
int ret = 0;
struct engine_operation *engine_ops = NULL;
engine_ops = engines_get_handler(runtime);
if (engine_ops == NULL || (engine_ops->engine_get_console_config_op) == NULL) {
ERROR("Failed to get engine get_console_config operation");
ret = -1;
goto out;
}
if (!engine_ops->engine_get_console_config_op(name, params->rootpath, params->config)) {
ERROR("Failed to get console config");
const char *tmpmsg = NULL;
tmpmsg = engine_ops->engine_get_errmsg_op();
lcrd_set_error_message("Get console config error;%s", (tmpmsg && strcmp(tmpmsg, DEF_SUCCESS_STR)) ?
tmpmsg : DEF_ERR_RUNTIME_STR);
ret = -1;
goto out;
}
out:
if (engine_ops != NULL) {
engine_ops->engine_clear_errmsg_op();
}
return ret;
}
int rt_lcr_status(const char *name, const char *runtime, const rt_status_params_t *params,
struct engine_container_info *status)
struct engine_container_status_info *status)
{
int ret = 0;
int nret = 0;
@ -299,9 +273,39 @@ int rt_lcr_status(const char *name, const char *runtime, const rt_status_params_
}
out:
if (engine_ops != NULL) {
engine_ops->engine_clear_errmsg_op();
}
return ret;
}
int rt_lcr_resources_stats(const char *name, const char *runtime, const rt_stats_params_t *params,
struct engine_container_resources_stats_info *rs_stats)
{
int ret = 0;
int nret = 0;
struct engine_operation *engine_ops = NULL;
engine_ops = engines_get_handler(runtime);
if (engine_ops == NULL || engine_ops->engine_get_container_resources_stats_op == NULL) {
ERROR("Failed to get engine stats operations");
ret = -1;
goto out;
}
nret = engine_ops->engine_get_container_resources_stats_op(name, params->rootpath, rs_stats);
if (nret != 0) {
engine_ops->engine_clear_errmsg_op();
ret = -1;
goto out;
}
out:
if (engine_ops != NULL) {
engine_ops->engine_clear_errmsg_op();
}
return ret;
}
int rt_lcr_exec(const char *id, const char *runtime, const rt_exec_params_t *params, int *exit_code)
{
int ret = 0;
@ -326,6 +330,7 @@ int rt_lcr_exec(const char *id, const char *runtime, const rt_exec_params_t *par
request.console_fifos = params->console_fifos;
request.timeout = params->timeout;
request.user = params->user;
request.suffix = params->suffix;
if (!engine_ops->engine_exec_op(&request, exit_code)) {
const char *tmpmsg = NULL;
@ -339,6 +344,9 @@ int rt_lcr_exec(const char *id, const char *runtime, const rt_exec_params_t *par
}
out:
if (engine_ops != NULL) {
engine_ops->engine_clear_errmsg_op();
}
return ret;
}
@ -360,11 +368,13 @@ int rt_lcr_pause(const char *name, const char *runtime, const rt_pause_params_t
tmpmsg = engine_ops->engine_get_errmsg_op();
lcrd_set_error_message("Pause container error;%s", (tmpmsg && strcmp(tmpmsg, DEF_SUCCESS_STR)) ?
tmpmsg : DEF_ERR_RUNTIME_STR);
engine_ops->engine_clear_errmsg_op();
ret = -1;
goto out;
}
out:
if (engine_ops != NULL) {
engine_ops->engine_clear_errmsg_op();
}
return ret;
}
@ -387,11 +397,177 @@ int rt_lcr_resume(const char *name, const char *runtime, const rt_resume_params_
lcrd_set_error_message("Resume container error;%s",
(tmpmsg && strcmp(tmpmsg, DEF_SUCCESS_STR)) ? tmpmsg
: DEF_ERR_RUNTIME_STR);
engine_ops->engine_clear_errmsg_op();
ret = -1;
goto out;
}
out:
if (engine_ops != NULL) {
engine_ops->engine_clear_errmsg_op();
}
return ret;
}
int rt_lcr_attach(const char *name, const char *runtime, const rt_attach_params_t *params)
{
int ret = 0;
struct engine_operation *engine_ops = NULL;
engine_ops = engines_get_handler(runtime);
if (engine_ops == NULL || engine_ops->engine_console_op == NULL) {
DEBUG("Failed to get engine attach operations");
ret = -1;
goto out;
}
if (!engine_ops->engine_console_op(name, params->rootpath, (char *)params->stdin, (char *)params->stdout,
(char *)params->stderr)) {
ERROR("attach failed");
const char *tmpmsg = NULL;
tmpmsg = engine_ops->engine_get_errmsg_op();
lcrd_set_error_message("Attach container error;%s", (tmpmsg && strcmp(tmpmsg, DEF_SUCCESS_STR)) ?
tmpmsg : DEF_ERR_RUNTIME_STR);
ret = -1;
goto out;
}
out:
if (engine_ops != NULL) {
engine_ops->engine_clear_errmsg_op();
}
return ret;
}
static void to_engine_resources(const host_config *hostconfig, struct engine_cgroup_resources *cr)
{
if (hostconfig == NULL || cr == NULL) {
return;
}
cr->blkio_weight = hostconfig->blkio_weight;
cr->cpu_shares = (uint64_t)hostconfig->cpu_shares;
cr->cpu_period = (uint64_t)hostconfig->cpu_period;
cr->cpu_quota = (uint64_t)hostconfig->cpu_quota;
cr->cpuset_cpus = hostconfig->cpuset_cpus;
cr->cpuset_mems = hostconfig->cpuset_mems;
cr->memory_limit = (uint64_t)hostconfig->memory;
cr->memory_swap = (uint64_t)hostconfig->memory_swap;
cr->memory_reservation = (uint64_t)hostconfig->memory_reservation;
cr->kernel_memory_limit = (uint64_t)hostconfig->kernel_memory;
}
int rt_lcr_update(const char *id, const char *runtime, const rt_update_params_t *params)
{
int ret = 0;
struct engine_operation *engine_ops = NULL;
struct engine_cgroup_resources cr = { 0 };
engine_ops = engines_get_handler(runtime);
if (engine_ops == NULL || engine_ops->engine_update_op == NULL) {
DEBUG("Failed to get engine update operations");
ret = -1;
goto out;
}
to_engine_resources(params->hostconfig, &cr);
if (!engine_ops->engine_update_op(id, params->rootpath, &cr)) {
DEBUG("Update container %s failed", id);
const char *tmpmsg = NULL;
tmpmsg = engine_ops->engine_get_errmsg_op();
lcrd_set_error_message("Cannot update container %s: %s", id, (tmpmsg && strcmp(tmpmsg, DEF_SUCCESS_STR)) ?
tmpmsg : DEF_ERR_RUNTIME_STR);
ret = -1;
goto out;
}
out:
if (engine_ops != NULL) {
engine_ops->engine_clear_errmsg_op();
}
return ret;
}
int rt_lcr_listpids(const char *name, const char *runtime, const rt_listpids_params_t *params, rt_listpids_out_t *out)
{
int ret = 0;
struct engine_operation *engine_ops = NULL;
engine_ops = engines_get_handler(runtime);
if (engine_ops == NULL || engine_ops->engine_get_container_pids_op == NULL) {
DEBUG("Failed to get engine top operations");
ret = -1;
goto out;
}
if (!engine_ops->engine_get_container_pids_op(name, params->rootpath, &(out->pids), &(out->pids_len))) {
DEBUG("Top container %s failed", name);
const char *tmpmsg = NULL;
tmpmsg = engine_ops->engine_get_errmsg_op();
lcrd_set_error_message("Runtime top container error: %s",
(tmpmsg && strcmp(tmpmsg, DEF_SUCCESS_STR)) ? tmpmsg : DEF_ERR_RUNTIME_STR);
ret = -1;
goto out;
}
out:
if (engine_ops != NULL) {
engine_ops->engine_clear_errmsg_op();
}
return ret;
}
int rt_lcr_resize(const char *id, const char *runtime, const rt_resize_params_t *params)
{
int ret = 0;
struct engine_operation *engine_ops = NULL;
engine_ops = engines_get_handler(runtime);
if (engine_ops == NULL || engine_ops->engine_resize_op == NULL) {
DEBUG("Failed to get engine resume operations");
ret = -1;
goto out;
}
if (!engine_ops->engine_resize_op(id, params->rootpath, params->height, params->width)) {
DEBUG("resize container %s failed", id);
const char *tmpmsg = NULL;
tmpmsg = engine_ops->engine_get_errmsg_op();
lcrd_set_error_message("Resize container error;%s",
(tmpmsg && strcmp(tmpmsg, DEF_SUCCESS_STR)) ? tmpmsg
: DEF_ERR_RUNTIME_STR);
ret = -1;
goto out;
}
out:
if (engine_ops != NULL) {
engine_ops->engine_clear_errmsg_op();
}
return ret;
}
int rt_lcr_exec_resize(const char *id, const char *runtime, const rt_exec_resize_params_t *params)
{
int ret = 0;
struct engine_operation *engine_ops = NULL;
engine_ops = engines_get_handler(runtime);
if (engine_ops == NULL || engine_ops->engine_resize_op == NULL) {
DEBUG("Failed to get engine resume operations");
ret = -1;
goto out;
}
if (!engine_ops->engine_exec_resize_op(id, params->rootpath, params->suffix, params->height, params->width)) {
DEBUG("exec resize container %s failed", id);
const char *tmpmsg = NULL;
tmpmsg = engine_ops->engine_get_errmsg_op();
lcrd_set_error_message("Resize container error;%s",
(tmpmsg && strcmp(tmpmsg, DEF_SUCCESS_STR)) ? tmpmsg
: DEF_ERR_RUNTIME_STR);
ret = -1;
goto out;
}
out:
if (engine_ops != NULL) {
engine_ops->engine_clear_errmsg_op();
}
return ret;
}

12
src/runtime/lcr/lcr_rt_ops.h
View File

@ -28,13 +28,21 @@ int rt_lcr_start(const char *name, const char *runtime, const rt_start_params_t
int rt_lcr_restart(const char *name, const char *runtime, const rt_restart_params_t *params);
int rt_lcr_clean_resource(const char *name, const char *runtime, const rt_clean_params_t *params);
int rt_lcr_rm(const char *name, const char *runtime, const rt_rm_params_t *params);
int rt_lcr_get_console_config(const char *name, const char *runtime, const rt_get_console_conf_params_t *params);
int rt_lcr_status(const char *name, const char *runtime, const rt_status_params_t *params,
struct engine_container_info *status);
struct engine_container_status_info *status);
int rt_lcr_exec(const char *id, const char *runtime, const rt_exec_params_t *params, int *exit_code);
int rt_lcr_pause(const char *name, const char *runtime, const rt_pause_params_t *params);
int rt_lcr_resume(const char *name, const char *runtime, const rt_resume_params_t *params);
int rt_lcr_attach(const char *name, const char *runtime, const rt_attach_params_t *params);
int rt_lcr_update(const char *id, const char *runtime, const rt_update_params_t *params);
int rt_lcr_listpids(const char *name, const char *runtime, const rt_listpids_params_t *params, rt_listpids_out_t *out);
int rt_lcr_resources_stats(const char *name, const char *runtime, const rt_stats_params_t *params,
struct engine_container_resources_stats_info *rs_stats);
int rt_lcr_resize(const char *id, const char *runtime, const rt_resize_params_t *params);
int rt_lcr_exec_resize(const char *id, const char *runtime, const rt_exec_resize_params_t *params);
#ifdef __cplusplus
}
#endif

191
src/runtime/runtime.c
View File

@ -33,11 +33,16 @@ static const struct rt_ops g_lcr_rt_ops = {
.rt_restart = rt_lcr_restart,
.rt_clean_resource = rt_lcr_clean_resource,
.rt_rm = rt_lcr_rm,
.rt_get_console_config = rt_lcr_get_console_config,
.rt_status = rt_lcr_status,
.rt_exec = rt_lcr_exec,
.rt_pause = rt_lcr_pause,
.rt_resume = rt_lcr_resume,
.rt_attach = rt_lcr_attach,
.rt_update = rt_lcr_update,
.rt_listpids = rt_lcr_listpids,
.rt_resources_stats = rt_lcr_resources_stats,
.rt_resize = rt_lcr_resize,
.rt_exec_resize = rt_lcr_exec_resize,
};
static const struct rt_ops *g_rt_ops[] = {
@ -184,38 +189,14 @@ out:
return ret;
}
int runtime_get_console_config(const char *name, const char *runtime, const rt_get_console_conf_params_t *params)
{
int ret = 0;
const struct rt_ops *ops = NULL;
if (name == NULL || runtime == NULL) {
ERROR("Invalide arguments for runtime get console config");
ret = -1;
goto out;
}
ops = rt_ops_query(runtime);
if (ops == NULL) {
ERROR("Failed to get runtime ops");
ret = -1;
goto out;
}
ret = ops->rt_get_console_config(name, runtime, params);
out:
return ret;
}
int runtime_status(const char *name, const char *runtime, const rt_status_params_t *params,
struct engine_container_info *status)
struct engine_container_status_info *status)
{
int ret = 0;
const struct rt_ops *ops = NULL;
if (name == NULL || runtime == NULL || status == NULL) {
ERROR("Invalide arguments for runtime start");
ERROR("Invalide arguments for runtime status");
ret = -1;
goto out;
}
@ -233,6 +214,31 @@ out:
return ret;
}
int runtime_resources_stats(const char *name, const char *runtime, const rt_stats_params_t *params,
struct engine_container_resources_stats_info *rs_stats)
{
int ret = 0;
const struct rt_ops *ops = NULL;
if (name == NULL || runtime == NULL || rs_stats == NULL) {
ERROR("Invalide arguments for runtime stats");
ret = -1;
goto out;
}
ops = rt_ops_query(runtime);
if (ops == NULL) {
ERROR("Failed to get runtime ops");
ret = -1;
goto out;
}
ret = ops->rt_resources_stats(name, runtime, params, rs_stats);
out:
return ret;
}
int runtime_exec(const char *name, const char *runtime, const rt_exec_params_t *params,
int *exit_code)
{
@ -305,3 +311,134 @@ int runtime_resume(const char *name, const char *runtime, const rt_resume_params
out:
return ret;
}
int runtime_attach(const char *name, const char *runtime, const rt_attach_params_t *params)
{
int ret = 0;
const struct rt_ops *ops = NULL;
if (name == NULL || runtime == NULL || params == NULL) {
ERROR("Invalide arguments for runtime attach");
ret = -1;
goto out;
}
ops = rt_ops_query(runtime);
if (ops == NULL) {
ERROR("Failed to get runtime ops");
ret = -1;
goto out;
}
ret = ops->rt_attach(name, runtime, params);
out:
return ret;
}
int runtime_update(const char *name, const char *runtime, const rt_update_params_t *params)
{
int ret = 0;
const struct rt_ops *ops = NULL;
if (name == NULL || runtime == NULL || params == NULL) {
ERROR("Invalide arguments for runtime update");
ret = -1;
goto out;
}
ops = rt_ops_query(runtime);
if (ops == NULL) {
ERROR("Failed to get runtime ops");
ret = -1;
goto out;
}
ret = ops->rt_update(name, runtime, params);
out:
return ret;
}
void free_rt_listpids_out_t(rt_listpids_out_t *out)
{
if (out == NULL) {
return;
}
free(out->pids);
out->pids = NULL;
free(out);
}
int runtime_listpids(const char *name, const char *runtime, const rt_listpids_params_t *params, rt_listpids_out_t *out)
{
int ret = 0;
const struct rt_ops *ops = NULL;
if (name == NULL || runtime == NULL || params == NULL || out == NULL) {
ERROR("Invalide arguments for runtime listpids");
ret = -1;
goto out;
}
ops = rt_ops_query(runtime);
if (ops == NULL) {
ERROR("Failed to get runtime ops");
ret = -1;
goto out;
}
ret = ops->rt_listpids(name, runtime, params, out);
out:
return ret;
}
int runtime_resize(const char *name, const char *runtime, const rt_resize_params_t *params)
{
int ret = 0;
const struct rt_ops *ops = NULL;
if (name == NULL || runtime == NULL || params == NULL) {
ERROR("Invalide arguments for runtime resize");
ret = -1;
goto out;
}
ops = rt_ops_query(runtime);
if (ops == NULL) {
ERROR("Failed to get runtime ops");
ret = -1;
goto out;
}
ret = ops->rt_resize(name, runtime, params);
out:
return ret;
}
int runtime_exec_resize(const char *name, const char *runtime, const rt_exec_resize_params_t *params)
{
int ret = 0;
const struct rt_ops *ops = NULL;
if (name == NULL || runtime == NULL || params == NULL) {
ERROR("Invalide arguments for runtime exec resize");
ret = -1;
goto out;
}
ops = rt_ops_query(runtime);
if (ops == NULL) {
ERROR("Failed to get runtime ops");
ret = -1;
goto out;
}
ret = ops->rt_exec_resize(name, runtime, params);
out:
return ret;
}

72
src/runtime/runtime.h
View File

@ -73,15 +73,14 @@ typedef struct _rt_rm_params_t {
const char *rootpath;
} rt_rm_params_t;
typedef struct _rt_get_console_conf_params_t {
const char *rootpath;
struct engine_console_config *config;
} rt_get_console_conf_params_t;
typedef struct _rt_status_params_t {
const char *rootpath;
} rt_status_params_t;
typedef struct _rt_stats_params_t {
const char *rootpath;
} rt_stats_params_t;
typedef struct _rt_exec_params_t {
const char *rootpath;
const char *logpath;
@ -93,6 +92,7 @@ typedef struct _rt_exec_params_t {
size_t args_len;
const char * const *envs;
size_t envs_len;
const char *suffix;
} rt_exec_params_t;
typedef struct _rt_pause_params_t {
@ -103,6 +103,40 @@ typedef struct _rt_resume_params_t {
const char *rootpath;
} rt_resume_params_t;
typedef struct _rt_attach_params_t {
const char *rootpath;
const char *stdin;
const char *stdout;
const char *stderr;
} rt_attach_params_t;
typedef struct _rt_update_params_t {
const char *rootpath;
const host_config *hostconfig;
} rt_update_params_t;
typedef struct _rt_listpids_params_t {
const char *rootpath;
} rt_listpids_params_t;
typedef struct _rt_listpids_out_t {
pid_t *pids;
size_t pids_len;
} rt_listpids_out_t;
typedef struct _rt_resize_params_t {
const char *rootpath;
unsigned int height;
unsigned int width;
} rt_resize_params_t;
typedef struct _rt_exec_resize_params_t {
const char *rootpath;
const char *suffix;
unsigned int height;
unsigned int width;
} rt_exec_resize_params_t;
struct rt_ops {
/* detect whether runtime is of this runtime type */
bool (*detect)(const char *runtime);
@ -118,16 +152,26 @@ struct rt_ops {
int (*rt_rm)(const char *name, const char *runtime, const rt_rm_params_t *params);
int (*rt_get_console_config)(const char *name, const char *runtime, const rt_get_console_conf_params_t *params);
int (*rt_status)(const char *name, const char *runtime, const rt_status_params_t *params,
struct engine_container_info *status);
struct engine_container_status_info *status);
int (*rt_resources_stats)(const char *name, const char *runtime, const rt_stats_params_t *params,
struct engine_container_resources_stats_info *rs_stats);
int (*rt_exec)(const char *name, const char *runtime, const rt_exec_params_t *params,
int *exit_code);
int (*rt_pause)(const char *name, const char *runtime, const rt_pause_params_t *params);
int (*rt_resume)(const char *name, const char *runtime, const rt_resume_params_t *params);
int (*rt_attach)(const char *name, const char *runtime, const rt_attach_params_t *params);
int (*rt_update)(const char *name, const char *runtime, const rt_update_params_t *params);
int (*rt_listpids)(const char *name, const char *runtime, const rt_listpids_params_t *params,
rt_listpids_out_t *out);
int (*rt_resize)(const char *name, const char *runtime, const rt_resize_params_t *params);
int (*rt_exec_resize)(const char *name, const char *runtime, const rt_exec_resize_params_t *params);
};
int runtime_create(const char *name, const char *runtime, const rt_create_params_t *params);
@ -135,14 +179,22 @@ int runtime_clean_resource(const char *name, const char *runtime, const rt_clean
int runtime_start(const char *name, const char *runtime, const rt_start_params_t *params, container_pid_t *pid_info);
int runtime_restart(const char *name, const char *runtime, const rt_restart_params_t *params);
int runtime_rm(const char *name, const char *runtime, const rt_rm_params_t *params);
int runtime_get_console_config(const char *name, const char *runtime, const rt_get_console_conf_params_t *params);
int runtime_status(const char *name, const char *runtime, const rt_status_params_t *params,
struct engine_container_info *status);
struct engine_container_status_info *status);
int runtime_resources_stats(const char *name, const char *runtime, const rt_stats_params_t *params,
struct engine_container_resources_stats_info *rs_stats);
int runtime_exec(const char *name, const char *runtime, const rt_exec_params_t *params,
int *exit_code);
int runtime_pause(const char *name, const char *runtime, const rt_pause_params_t *params);
int runtime_resume(const char *name, const char *runtime, const rt_resume_params_t *params);
int runtime_attach(const char *name, const char *runtime, const rt_attach_params_t *params);
int runtime_update(const char *name, const char *runtime, const rt_update_params_t *params);
int runtime_listpids(const char *name, const char *runtime, const rt_listpids_params_t *params, rt_listpids_out_t *out);
void free_rt_listpids_out_t(rt_listpids_out_t *out);
int runtime_resize(const char *name, const char *runtime, const rt_resize_params_t *params);
int runtime_exec_resize(const char *name, const char *runtime, const rt_exec_resize_params_t *params);
#ifdef __cplusplus
}
#endif

4
src/services/callback.h
View File

@ -123,8 +123,6 @@ typedef struct {
int(*inspect)(const container_inspect_request *request, container_inspect_response **response);
int(*conf)(const struct lcrd_container_conf_request *request, struct lcrd_container_conf_response **response);
int(*wait)(const container_wait_request *request, container_wait_response **response);
int(*events)(const struct lcrd_events_request *request, const stream_func_wrapper *stream);
@ -140,6 +138,8 @@ typedef struct {
int(*logs)(const struct lcrd_logs_request *request,
stream_func_wrapper *stream, struct lcrd_logs_response **response);
int(*resize)(const struct lcrd_container_resize_request *request, struct lcrd_container_resize_response **response);
} service_container_callback_t;
typedef struct {

94
src/services/cri/cri_container.cc
View File

@ -811,14 +811,74 @@ cleanup:
free_container_list_response(response);
}
void CRIRuntimeServiceImpl::PackContainerStatsAttributes(
const char *id,
std::unique_ptr<runtime::v1alpha2::ContainerStats> &container,
Errors &error)
{
if (id == nullptr) {
return;
}
container->mutable_attributes()->set_id(id);
auto status = ContainerStatus(std::string(id), error);
if (status->has_metadata()) {
std::unique_ptr<runtime::v1alpha2::ContainerMetadata> metadata(
new (std::nothrow) runtime::v1alpha2::ContainerMetadata(status->metadata()));
if (metadata == nullptr) {
error.SetError("Out of memory");
ERROR("Out of memory");
return;
}
container->mutable_attributes()->set_allocated_metadata(metadata.release());
}
if (status->labels_size() > 0) {
auto labels = container->mutable_attributes()->mutable_labels();
*labels = status->labels();
}
if (status->annotations_size() > 0) {
auto annotations = container->mutable_attributes()->mutable_annotations();
*annotations = status->annotations();
}
}
void CRIRuntimeServiceImpl::PackContainerStatsFilesystemUsage(
const char *id, const char *image_type,
std::unique_ptr<runtime::v1alpha2::ContainerStats> &container,
Errors &error)
{
if (id == nullptr || image_type == nullptr) {
return;
}
imagetool_fs_info *fs_usage { nullptr };
if (im_get_container_filesystem_usage(image_type, id, &fs_usage) != 0) {
ERROR("Failed to get container filesystem usage");
}
if (fs_usage == nullptr) {
container->mutable_writable_layer()->mutable_used_bytes()->set_value(0);
container->mutable_writable_layer()->mutable_inodes_used()->set_value(0);
} else {
if (fs_usage->image_filesystems[0]->used_bytes->value) {
container->mutable_writable_layer()->mutable_used_bytes()->set_value(
fs_usage->image_filesystems[0]->used_bytes->value);
}
if (fs_usage->image_filesystems[0]->inodes_used->value) {
container->mutable_writable_layer()->mutable_inodes_used()->set_value(
fs_usage->image_filesystems[0]->inodes_used->value);
}
}
free_imagetool_fs_info(fs_usage);
}
void CRIRuntimeServiceImpl::ContainerStatsToGRPC(
container_stats_response *response,
std::vector<std::unique_ptr<runtime::v1alpha2::ContainerStats>> *containerstats, Errors &error)
{
int ret {};
for (size_t i {}; i < response->container_stats_len; i++) {
imagetool_fs_info *fs_usage { nullptr };
using ContainerStatsPtr = std::unique_ptr<runtime::v1alpha2::ContainerStats>;
ContainerStatsPtr container(new (std::nothrow) runtime::v1alpha2::ContainerStats);
if (container == nullptr) {
@ -826,14 +886,12 @@ void CRIRuntimeServiceImpl::ContainerStatsToGRPC(
return;
}
if (response->container_stats[i]->id != nullptr && response->container_stats[i]->image_type != nullptr) {
container->mutable_attributes()->set_id(response->container_stats[i]->id);
ret = im_get_container_filesystem_usage(response->container_stats[i]->image_type,
response->container_stats[i]->id, &fs_usage);
if (ret != 0) {
ERROR("Failed to get container filesystem usage");
}
PackContainerStatsAttributes(response->container_stats[i]->id, container, error);
if (error.NotEmpty()) {
return;
}
PackContainerStatsFilesystemUsage(response->container_stats[i]->id,
response->container_stats[i]->image_type, container, error);
if (response->container_stats[i]->mem_used) {
container->mutable_memory()->mutable_working_set_bytes()->set_value(response->container_stats[i]->mem_used);
@ -845,23 +903,7 @@ void CRIRuntimeServiceImpl::ContainerStatsToGRPC(
container->mutable_cpu()->set_timestamp((int64_t)(response->container_stats[i]->cpu_system_use));
}
if (fs_usage == nullptr) {
container->mutable_writable_layer()->mutable_used_bytes()->set_value(0);
container->mutable_writable_layer()->mutable_inodes_used()->set_value(0);
}
if (fs_usage != nullptr) {
if (fs_usage->image_filesystems[0]->used_bytes->value) {
container->mutable_writable_layer()->mutable_used_bytes()->set_value(
fs_usage->image_filesystems[0]->used_bytes->value);
}
if (fs_usage->image_filesystems[0]->inodes_used->value) {
container->mutable_writable_layer()->mutable_inodes_used()->set_value(
fs_usage->image_filesystems[0]->inodes_used->value);
}
}
containerstats->push_back(move(container));
free_imagetool_fs_info(fs_usage);
}
}

7
src/services/cri/cri_runtime_service.h
View File

@ -143,6 +143,13 @@ private:
void ListContainersToGRPC(container_list_response *response,
std::vector<std::unique_ptr<runtime::v1alpha2::Container>> *pods, Errors &error);
void PackContainerStatsAttributes(const char *id, std::unique_ptr<runtime::v1alpha2::ContainerStats> &container,
Errors &error);
void PackContainerStatsFilesystemUsage(const char *id, const char *image_type,
std::unique_ptr<runtime::v1alpha2::ContainerStats> &container,
Errors &error);
void ContainerStatsToGRPC(container_stats_response *response,
std::vector<std::unique_ptr<runtime::v1alpha2::ContainerStats>> *pods, Errors &error);

3
src/services/cri/cri_security_context.cc
View File

@ -174,9 +174,10 @@ static void ModifyHostNetworkOptionForSandbox(const runtime::v1alpha2::Namespace
static void ModifyContainerNamespaceOptions(const runtime::v1alpha2::NamespaceOption &nsOpts,
const std::string &podSandboxID, host_config *hostConfig, Errors &error)
{
std::string sandboxNSMode = "container:" + podSandboxID;
if (nsOpts.pid() == runtime::v1alpha2::NamespaceMode::POD) {
free(hostConfig->pid_mode);
hostConfig->pid_mode = util_strdup_s("");
hostConfig->pid_mode = util_strdup_s(sandboxNSMode.c_str());
}
/* set common Namespace options */

35
src/services/execution/execute/execution_create.c
View File

@ -212,39 +212,6 @@ error_out:
return NULL;
}
static int generateID(char *id, size_t len)
{
int fd = -1;
int num = 0;
size_t i;
const int m = 256;
len = len / 2;
fd = open("/dev/urandom", O_RDONLY);
if (fd == -1) {
ERROR("Failed to open /dev/urandom");
return -1;
}
for (i = 0; i < len; i++) {
int nret;
if (read(fd, &num, sizeof(int)) < 0) {
ERROR("Failed to read urandom value");
close(fd);
return -1;
}
unsigned char rs = (unsigned char)(num % m);
nret = snprintf((id + i * 2), ((len - i) * 2 + 1), "%02x", (unsigned int)rs);
if (nret >= ((len - i) * 2 + 1) || nret < 0) {
close(fd);
return -1;
}
}
close(fd);
id[i * 2] = '\0';
return 0;
}
static oci_runtime_spec *merge_config(const char *id, const char *image_type, const char *image_name,
const char *ext_config_image, host_config *host_spec,
container_custom_config *custom_spec,
@ -311,7 +278,7 @@ static char *try_generate_id()
}
for (i = 0; i < max_time; i++) {
if (generateID(id, (size_t)CONTAINER_ID_MAX_LEN)) {
if (util_generate_random_str(id, (size_t)CONTAINER_ID_MAX_LEN)) {
ERROR("Generate id failed");
goto err_out;
}

271
src/services/execution/execute/execution_extend.c
View File

@ -213,7 +213,8 @@ static int copy_map_labels(const container_config *config, map_t **map_labels)
return 0;
}
static container_info *get_container_stats(const container_t *cont, const struct engine_container_info *einfo,
static container_info *get_container_stats(const container_t *cont,
const struct engine_container_resources_stats_info *einfo,
const struct stats_context *ctx)
{
int ret = 0;
@ -229,9 +230,6 @@ static container_info *get_container_stats(const container_t *cont, const struct
}
info->id = util_strdup_s(cont->common_config->id);
info->has_pid = einfo->has_pid;
info->pid = (int32_t)einfo->pid;
info->status = (int)einfo->status;
info->pids_current = einfo->pids_current;
info->cpu_use_nanos = einfo->cpu_use_nanos;
info->blkio_read = einfo->blkio_read;
@ -395,29 +393,12 @@ cleanup:
return ret;
}
static int get_containers_stats(const char *runtime, char **idsarray, size_t ids_len, const struct stats_context *ctx,
static int get_containers_stats(char **idsarray, size_t ids_len, const struct stats_context *ctx,
bool check_exists, container_info ***info, size_t *info_len)
{
int ret = 0;
int nret;
size_t i;
char *engine_path = NULL;
struct engine_operation *engine_ops = NULL;
engine_ops = engines_get_handler(runtime);
if (engine_ops == NULL || engine_ops->engine_get_container_status_op == NULL ||
engine_ops->engine_free_container_status_op == NULL) {
ERROR("Failed to get engine stats operations");
ret = -1;
goto cleanup;
}
engine_path = conf_get_routine_rootdir(runtime);
if (engine_path == NULL) {
ERROR("Get engine path failed");
ret = -1;
goto cleanup;
}
nret = service_stats_make_memory(info, ids_len);
if (nret != 0) {
@ -426,7 +407,7 @@ static int get_containers_stats(const char *runtime, char **idsarray, size_t ids
}
for (i = 0; i < ids_len; i++) {
struct engine_container_info einfo = { 0 };
struct engine_container_resources_stats_info einfo = { 0 };
container_t *cont = NULL;
cont = containers_store_get(idsarray[i]);
@ -440,9 +421,11 @@ static int get_containers_stats(const char *runtime, char **idsarray, size_t ids
continue;
}
if (is_running(cont->state)) {
nret = engine_ops->engine_get_container_status_op(cont->common_config->id, engine_path, &einfo);
rt_stats_params_t params = { 0 };
params.rootpath = cont->root_path;
nret = runtime_resources_stats(cont->common_config->id, cont->runtime, &params, &einfo);
if (nret != 0) {
engine_ops->engine_clear_errmsg_op();
container_unref(cont);
continue;
}
@ -455,14 +438,12 @@ static int get_containers_stats(const char *runtime, char **idsarray, size_t ids
(*info)[*info_len] = get_container_stats(cont, &einfo, ctx);
container_unref(cont);
engine_ops->engine_free_container_status_op(&einfo);
if ((*info)[*info_len] == NULL) {
continue;
}
(*info_len)++;
}
cleanup:
free(engine_path);
return ret;
}
@ -490,12 +471,6 @@ static int container_stats_cb(const container_stats_request *request,
goto pack_response;
}
if (request->runtime == NULL) {
ERROR("Receive NULL Request runtime");
cc = LCRD_ERR_INPUT;
goto pack_response;
}
ctx = fold_stats_filter(request);
if (ctx == NULL) {
cc = LCRD_ERR_EXEC;
@ -510,7 +485,7 @@ static int container_stats_cb(const container_stats_request *request,
goto pack_response;
}
if (get_containers_stats(request->runtime, idsarray, ids_len, ctx, check_exists, &info, &info_len)) {
if (get_containers_stats(idsarray, ids_len, ctx, check_exists, &info, &info_len)) {
cc = LCRD_ERR_EXEC;
goto pack_response;
}
@ -553,6 +528,7 @@ static int resume_container(container_t *cont)
}
state_reset_paused(cont->state);
update_health_monitor(cont->common_config->id);
if (container_to_disk(cont)) {
@ -739,6 +715,7 @@ static int pause_container(container_t *cont)
}
state_set_paused(cont->state);
update_health_monitor(cont->common_config->id);
if (container_to_disk(cont)) {
@ -840,24 +817,6 @@ pack_response:
return (cc == LCRD_SUCCESS) ? 0 : -1;
}
static void to_engine_resources(const host_config *hostconfig, struct engine_cgroup_resources *cr)
{
if (hostconfig == NULL || cr == NULL) {
return;
}
cr->blkio_weight = hostconfig->blkio_weight;
cr->cpu_shares = (uint64_t)hostconfig->cpu_shares;
cr->cpu_period = (uint64_t)hostconfig->cpu_period;
cr->cpu_quota = (uint64_t)hostconfig->cpu_quota;
cr->cpuset_cpus = hostconfig->cpuset_cpus;
cr->cpuset_mems = hostconfig->cpuset_mems;
cr->memory_limit = (uint64_t)hostconfig->memory;
cr->memory_swap = (uint64_t)hostconfig->memory_swap;
cr->memory_reservation = (uint64_t)hostconfig->memory_reservation;
cr->kernel_memory_limit = (uint64_t)hostconfig->kernel_memory;
}
static void host_config_restore_unlocking(container_t *cont, host_config *backup_hostconfig)
{
free_host_config(cont->hostconfig);
@ -1034,32 +993,6 @@ out:
return ret;
}
static int runtime_update(const char *id, const char *runtime, const char *rootpath, struct engine_cgroup_resources *cr)
{
int ret = 0;
struct engine_operation *engine_ops = NULL;
engine_ops = engines_get_handler(runtime);
if (engine_ops == NULL || engine_ops->engine_update_op == NULL) {
DEBUG("Failed to get engine update operations");
ret = -1;
goto out;
}
if (!engine_ops->engine_update_op(id, rootpath, cr)) {
DEBUG("Update container %s failed", id);
const char *tmpmsg = NULL;
tmpmsg = engine_ops->engine_get_errmsg_op();
lcrd_set_error_message("Cannot update container %s: %s", id, (tmpmsg && strcmp(tmpmsg, DEF_SUCCESS_STR)) ?
tmpmsg : DEF_ERR_RUNTIME_STR);
engine_ops->engine_clear_errmsg_op();
ret = -1;
goto out;
}
out:
return ret;
}
static int do_update_resources(const container_update_request *request, container_t *cont)
{
int ret = 0;
@ -1067,7 +1000,7 @@ static int do_update_resources(const container_update_request *request, containe
parser_error err = NULL;
host_config *hostconfig = NULL;
host_config *backup_hostconfig = NULL;
struct engine_cgroup_resources cr = { 0 };
rt_update_params_t params = { 0 };
if (request->host_config == NULL) {
DEBUG("receive NULL host config");
@ -1111,10 +1044,10 @@ static int do_update_resources(const container_update_request *request, containe
container_update_restart_manager(cont, hostconfig->restart_policy);
}
to_engine_resources(hostconfig, &cr);
if (runtime_update(id, cont->runtime, cont->root_path, &cr)) {
params.rootpath = cont->root_path;
params.hostconfig = hostconfig;
if (runtime_update(id, cont->runtime, &params)) {
ERROR("Update container %s failed", id);
host_config_restore_unlocking(cont, backup_hostconfig);
ret = -1;
goto unlock_out;
}
@ -1291,6 +1224,179 @@ pack_response:
return (cc == LCRD_SUCCESS) ? 0 : -1;
}
static int runtime_resize_helper(const char *id, const char *runtime, const char *rootpath, unsigned int height,
unsigned int width)
{
int ret = 0;
rt_resize_params_t params = { 0 };
params.rootpath = rootpath;
params.height = height;
params.width = width;
ret = runtime_resize(id, runtime, &params);
if (ret != 0) {
ERROR("Failed to resize container %s", id);
}
return ret;
}
static int runtime_exec_resize_helper(const char *id, const char *runtime, const char *rootpath, const char *suffix,
unsigned int height,
unsigned int width)
{
int ret = 0;
rt_exec_resize_params_t params = { 0 };
params.rootpath = rootpath;
params.suffix = suffix;
params.height = height;
params.width = width;
ret = runtime_exec_resize(id, runtime, &params);
if (ret != 0) {
ERROR("Failed to resize container %s", id);
}
return ret;
}
static int resize_container(container_t *cont, const char *suffix, unsigned int height, unsigned int width)
{
int ret = 0;
const char *id = cont->common_config->id;
container_lock(cont);
if (!is_running(cont->state)) {
ERROR("Container %s is not running", id);
lcrd_set_error_message("Container %s is not running", id);
ret = -1;
goto out;
}
if (suffix != NULL) {
DEBUG("Failed to resize container:%s suffix:%s", id, suffix);
if (runtime_exec_resize_helper(id, cont->runtime, cont->root_path, suffix, height, width)) {
ERROR("Failed to resize container:%s", id);
ret = -1;
goto out;
}
} else {
if (runtime_resize_helper(id, cont->runtime, cont->root_path, height, width)) {
ERROR("Failed to resize container:%s", id);
ret = -1;
goto out;
}
}
out:
container_unlock(cont);
return ret;
}
static void pack_resize_response(struct lcrd_container_resize_response *response, uint32_t cc, const char *id)
{
if (response == NULL) {
return;
}
response->cc = cc;
if (id != NULL) {
response->id = util_strdup_s(id);
}
if (g_lcrd_errmsg != NULL) {
response->errmsg = util_strdup_s(g_lcrd_errmsg);
DAEMON_CLEAR_ERRMSG();
}
}
static int resize_request_check(const struct lcrd_container_resize_request *request)
{
int ret = 0;
char *name = request->id;
if (name == NULL) {
ERROR("Resume: receive NULL id");
ret = -1;
goto out;
}
if (!util_valid_container_id_or_name(name)) {
ERROR("Invalid container name %s", name);
lcrd_set_error_message("Invalid container name %s", name);
ret = -1;
goto out;
}
if (request->suffix != NULL && !util_valid_exec_suffix(request->suffix)) {
ERROR("Invalid suffix name %s", name);
lcrd_set_error_message("Invalid suffix name %s", name);
ret = -1;
goto out;
}
out:
return ret;
}
static int container_resize_cb(const struct lcrd_container_resize_request *request,
struct lcrd_container_resize_response **response)
{
int ret = 0;
uint32_t cc = LCRD_SUCCESS;
char *name = NULL;
char *id = NULL;
container_t *cont = NULL;
DAEMON_CLEAR_ERRMSG();
if (request == NULL || response == NULL) {
ERROR("Invalid NULL input");
return -1;
}
*response = util_common_calloc_s(sizeof(struct lcrd_container_resize_response));
if (*response == NULL) {
ERROR("Resume: Out of memory");
cc = LCRD_ERR_MEMOUT;
goto pack_response;
}
if (resize_request_check(request) != 0) {
cc = LCRD_ERR_INPUT;
goto pack_response;
}
name = request->id;
cont = containers_store_get(name);
if (cont == NULL) {
ERROR("No such container:%s", name);
lcrd_set_error_message("No such container:%s", name);
cc = LCRD_ERR_EXEC;
goto pack_response;
}
id = cont->common_config->id;
set_log_prefix(id);
EVENT("Event: {Object: %s, Type: Resizing}", id);
ret = resize_container(cont, request->suffix, request->height, request->width);
if (ret != 0) {
cc = LCRD_ERR_EXEC;
container_state_set_error(cont->state, (const char *)g_lcrd_errmsg);
goto pack_response;
}
EVENT("Event: {Object: %s, Type: Resized}", id);
pack_response:
pack_resize_response(*response, cc, id);
container_unref(cont);
free_log_prefix();
return (cc == LCRD_SUCCESS) ? 0 : -1;
}
void container_extend_callback_init(service_container_callback_t *cb)
{
cb->update = container_update_cb;
@ -1299,5 +1405,6 @@ void container_extend_callback_init(service_container_callback_t *cb)
cb->stats = container_stats_cb;
cb->events = container_events_cb;
cb->export_rootfs = container_export_cb;
cb->resize = container_resize_cb;
}

155
src/services/execution/execute/execution_information.c
View File

@ -456,7 +456,6 @@ out:
static inline void add_ps_array_elem(char **array, size_t *pos, const char *elem)
{
#define PARAM_NUM 100
if (*pos + 1 >= (PARAM_NUM - 1)) {
return;
}
@ -537,26 +536,48 @@ static int get_pids(const char *name, const char *runtime, const char *rootpath,
char **pid_args)
{
int ret = 0;
struct engine_operation *engine_ops = NULL;
size_t i = 0;
rt_listpids_params_t params = { 0 };
rt_listpids_out_t *out = NULL;
engine_ops = engines_get_handler(runtime);
if (engine_ops == NULL || engine_ops->engine_get_container_pids_op == NULL) {
DEBUG("Failed to get engine top operations");
out = util_common_calloc_s(sizeof(rt_listpids_out_t));
if (out == NULL) {
ERROR("Memeory out");
ret = -1;
goto out;
}
if (!engine_ops->engine_get_container_pids_op(name, rootpath, pids, pids_len)) {
DEBUG("Top container %s failed", name);
const char *tmpmsg = NULL;
tmpmsg = engine_ops->engine_get_errmsg_op();
lcrd_set_error_message("Runtime top container error: %s",
(tmpmsg && strcmp(tmpmsg, DEF_SUCCESS_STR)) ? tmpmsg : DEF_ERR_RUNTIME_STR);
params.rootpath = rootpath;
if (runtime_listpids(name, runtime, &params, out) != 0) {
ERROR("runtime failed to list pids");
ret = -1;
goto out;
}
if (out->pids_len > SIZE_MAX / sizeof(pid_t)) {
ERROR("list too many pids");
ret = -1;
goto out;
}
if (out->pids_len != 0) {
pid_t *tmp = NULL;
tmp = util_common_calloc_s(sizeof(pid_t) * out->pids_len);
if (tmp == NULL) {
ERROR("Memory out");
ret = -1;
goto out;
}
for (i = 0; i < out->pids_len; i++) {
tmp[i] = out->pids[i];
}
*pids = tmp;
}
*pids_len = out->pids_len;
*pid_args = ps_pids_arg(*pids, *pids_len);
if (*pid_args == NULL) {
ERROR("failed to get pid_args");
@ -564,9 +585,7 @@ static int get_pids(const char *name, const char *runtime, const char *rootpath,
goto out;
}
out:
if (engine_ops != NULL) {
engine_ops->engine_clear_errmsg_op();
}
free_rt_listpids_out_t(out);
return ret;
}
@ -1467,113 +1486,6 @@ pack_response:
return (cc == LCRD_SUCCESS) ? 0 : -1;
}
static int container_conf_request_check(const struct lcrd_container_conf_request *h)
{
int ret = 0;
if (h->name == NULL) {
ERROR("Receive NULL container name");
ret = -1;
goto out;
}
if (!util_valid_container_id_or_name(h->name)) {
ERROR("Invalid container name %s", h->name);
lcrd_set_error_message("Invalid container name %s", h->name);
ret = -1;
goto out;
}
out:
return ret;
}
static void pack_container_conf_response(struct lcrd_container_conf_response *response, uint32_t cc,
const struct engine_console_config *config)
{
if (response == NULL) {
return;
}
response->cc = cc;
if (g_lcrd_errmsg != NULL) {
response->errmsg = util_strdup_s(g_lcrd_errmsg);
DAEMON_CLEAR_ERRMSG();
}
if (config->log_path != NULL) {
response->container_logpath = util_strdup_s(config->log_path);
}
response->container_logrotate = (uint32_t)config->log_rotate;
if (config->log_file_size != NULL) {
response->container_logsize = util_strdup_s(config->log_file_size);
}
}
static int container_conf_cb(const struct lcrd_container_conf_request *request,
struct lcrd_container_conf_response **response)
{
char *id = NULL;
uint32_t cc = LCRD_SUCCESS;
struct engine_operation *engine_ops = NULL;
struct engine_console_config config = { 0 };
container_t *cont = NULL;
rt_get_console_conf_params_t params = { 0 };
DAEMON_CLEAR_ERRMSG();
if (request == NULL || response == NULL) {
ERROR("Invalid NULL input");
return -1;
}
*response = util_common_calloc_s(sizeof(struct lcrd_container_conf_response));
if (*response == NULL) {
ERROR("Out of memory");
cc = LCRD_ERR_MEMOUT;
goto pack_response;
}
if (container_conf_request_check(request) != 0) {
cc = LCRD_ERR_INPUT;
goto pack_response;
}
cont = containers_store_get(request->name);
if (cont == NULL) {
ERROR("No such container:%s", request->name);
lcrd_set_error_message("No such container:%s", request->name);
cc = LCRD_ERR_EXEC;
goto pack_response;
}
engine_ops = engines_get_handler(cont->runtime);
if (engine_ops == NULL || engine_ops->engine_free_console_config_op == NULL) {
ERROR("Failed to get engine free_console_config operation");
cc = LCRD_ERR_EXEC;
goto pack_response;
}
id = cont->common_config->id;
set_log_prefix(id);
params.rootpath = cont->root_path;
params.config = &config;
if (runtime_get_console_config(id, cont->runtime, &params) != 0) {
cc = LCRD_ERR_EXEC;
goto pack_response;
}
pack_response:
pack_container_conf_response(*response, cc, &config);
container_unref(cont);
if (engine_ops != NULL && engine_ops->engine_free_console_config_op != NULL) {
engine_ops->engine_free_console_config_op(&config);
}
free_log_prefix();
return (cc == LCRD_SUCCESS) ? 0 : -1;
}
static int rename_request_check(const struct lcrd_container_rename_request *request)
{
int ret = 0;
@ -1745,7 +1657,6 @@ void container_information_callback_init(service_container_callback_t *cb)
cb->inspect = container_inspect_cb;
cb->list = container_list_cb;
cb->wait = container_wait_cb;
cb->conf = container_conf_cb;
cb->top = container_top_cb;
cb->rename = container_rename_cb;
}

58
src/services/execution/execute/execution_stream.c
View File

@ -250,7 +250,7 @@ out:
static int exec_container(container_t *cont, const char *runtime, char * const console_fifos[], const char *user,
size_t argc, const char **argv, size_t env_len, const char **env,
int64_t timeout, int *exit_code)
int64_t timeout, const char *suffix, int *exit_code)
{
int ret = 0;
char *engine_log_path = NULL;
@ -287,6 +287,7 @@ static int exec_container(container_t *cont, const char *runtime, char * const c
params.args_len = argc;
params.envs = (const char * const *)env;
params.envs_len = env_len;
params.suffix = suffix;
if (runtime_exec(cont->common_config->id, runtime, &params, exit_code)) {
ERROR("Runtime exec container failed");
@ -332,6 +333,13 @@ static int container_exec_cb_check(const container_exec_request *request, contai
return -1;
}
if (request->suffix != NULL && !util_valid_exec_suffix(request->suffix)) {
ERROR("Invalid exec suffix %s", request->suffix);
lcrd_set_error_message("Invalid exec suffix %s", request->suffix);
*cc = LCRD_ERR_EXEC;
return -1;
}
*cont = containers_store_get(container_name);
if (*cont == NULL) {
ERROR("No such container:%s", container_name);
@ -564,7 +572,7 @@ static int container_exec_cb(const container_exec_request *request, container_ex
if (exec_container(cont, cont->runtime, (char * const *)fifos, user, request->argv_len,
(const char **)request->argv, request->env_len,
(const char **)request->env, request->timeout, &exit_code)) {
(const char **)request->env, request->timeout, request->suffix, &exit_code)) {
cc = LCRD_ERR_EXEC;
goto pack_response;
}
@ -698,7 +706,7 @@ static int container_attach_cb(const container_attach_request *request, containe
char *fifopath = NULL;
pthread_t tid = 0;
container_t *cont = NULL;
struct engine_operation *engine_ops = NULL;
rt_attach_params_t params = { 0 };
DAEMON_CLEAR_ERRMSG();
if (request == NULL || response == NULL) {
@ -725,21 +733,14 @@ static int container_attach_cb(const container_attach_request *request, containe
goto pack_response;
}
engine_ops = engines_get_handler(cont->runtime);
if (engine_ops == NULL || engine_ops->engine_console_op == NULL) {
DEBUG("Failed to get engine attach operations");
cc = LCRD_ERR_EXEC;
goto pack_response;
}
params.rootpath = cont->root_path;
params.stdin = fifos[0];
params.stdout = fifos[1];
params.stderr = fifos[2];
if (!engine_ops->engine_console_op(id, cont->root_path, fifos[0], fifos[1], fifos[2])) {
ERROR("attach failed");
if (runtime_attach(cont->common_config->id, cont->runtime, &params)) {
ERROR("Runtime attach container failed");
cc = LCRD_ERR_EXEC;
const char *tmpmsg = NULL;
tmpmsg = engine_ops->engine_get_errmsg_op();
lcrd_set_error_message("Attach container error;%s", (tmpmsg && strcmp(tmpmsg, DEF_SUCCESS_STR)) ?
tmpmsg : DEF_ERR_RUNTIME_STR);
engine_ops->engine_clear_errmsg_op();
goto pack_response;
}
@ -1796,6 +1797,20 @@ static int handle_rotate(int fd, int wd, const char *path)
return watch_fd;
}
static void cleanup_handler(void *arg)
{
int *fds = (int *)arg;
if (fds[0] < 0) {
return;
}
if (fds[1] >= 0 && inotify_rm_watch(fds[0], fds[1]) < 0) {
SYSERROR("Rm watch failed");
}
close(fds[0]);
}
static int hanlde_events(int fd, const struct follow_args *farg)
{
int write_cnt, rename_cnt;
@ -1805,17 +1820,21 @@ static int hanlde_events(int fd, const struct follow_args *farg)
ssize_t len = 0;
struct inotify_event *c_event = NULL;
char buf[MAXLINE] __attribute__((aligned(__alignof__(struct inotify_event)))) = { 0 };
int clean_fds[2] = { fd, -1 };
struct last_log_file_position last_pos = {
.file_index = farg->last_file_index,
.pos = farg->last_file_pos,
};
pthread_cleanup_push(cleanup_handler, clean_fds);
watch_fd = inotify_add_watch(fd, farg->path, IN_MODIFY | IN_DELETE | IN_MOVED_FROM | IN_MOVE_SELF);
if (watch_fd < 0) {
SYSERROR("Add watch %s failed", farg->path);
goto out;
}
clean_fds[1] = watch_fd;
for (;;) {
if (pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) != 0) {
@ -1866,9 +1885,7 @@ static int hanlde_events(int fd, const struct follow_args *farg)
}
out:
if (inotify_rm_watch(fd, watch_fd) < 0) {
SYSERROR("Rm watch failed");
}
pthread_cleanup_pop(1);
return ret;
}
@ -1881,7 +1898,7 @@ static void *follow_thread_func(void *arg)
INFO("Get args, path: %s, last pos: %ld, last file: %d", farg->path, farg->last_file_pos, farg->last_file_index);
inotify_fd = inotify_init();
inotify_fd = inotify_init1(IN_CLOEXEC);
if (inotify_fd < 0) {
SYSERROR("Init inotify failed");
goto set_flag;
@ -1891,7 +1908,6 @@ static void *follow_thread_func(void *arg)
ERROR("Handle inotify event failed");
}
close(inotify_fd);
set_flag:
*(farg->finish) = true;
return NULL;

75
src/services/execution/manager/container_unix.c
View File

@ -1255,46 +1255,6 @@ unlock:
return ret;
}
static container_pid_t *parse_container_pid(const char *S)
{
int num;
container_pid_t *P = NULL;
if (S == NULL) {
return NULL;
}
P = util_common_calloc_s(sizeof(container_pid_t));
if (P == NULL) {
return NULL;
}
num = sscanf(S, "%d %Lu %d %Lu", &P->pid, &P->start_time, &P->ppid, &P->pstart_time);
if (num != 4) { // args num to read is 4
ERROR("Call sscanf error: %s", errno ? strerror(errno) : "");
free(P);
return NULL;
}
return P;
}
container_pid_t *container_read_pidfile(const char *pidfile)
{
if (pidfile == NULL) {
ERROR("Invalid input arguments");
return NULL;
}
char sbuf[1024] = { 0 }; /* bufs for stat */
if ((util_file2str(pidfile, sbuf, sizeof(sbuf))) == -1) {
return NULL;
}
return parse_container_pid(sbuf);
}
char *container_get_env_nolock(const container_t *cont, const char *key)
{
size_t i = 0;
@ -1340,3 +1300,38 @@ char *container_get_env_nolock(const container_t *cont, const char *key)
return val;
}
int container_read_proc(uint32_t pid, container_pid_t *pid_info)
{
int ret = 0;
proc_t *proc = NULL;
proc_t *p_proc = NULL;
if (pid == 0) {
ret = -1;
goto out;
}
proc = util_get_process_proc_info((pid_t)pid);
if (proc == NULL) {
ret = -1;
goto out;
}
p_proc = util_get_process_proc_info((pid_t)proc->ppid);
if (p_proc == NULL) {
ret = -1;
goto out;
}
pid_info->pid = proc->pid;
pid_info->start_time = proc->start_time;
pid_info->ppid = proc->ppid;
pid_info->pstart_time = p_proc->start_time;
out:
free(proc);
free(p_proc);
return ret;
}

4
src/services/execution/manager/container_unix.h
View File

@ -106,11 +106,11 @@ int container_wait_stop_locking(container_t *cont, int timeout);
void container_wait_rm_cond_broadcast(container_t *cont);
int container_wait_rm_locking(container_t *cont, int timeout);
container_pid_t *container_read_pidfile(const char *pidfile);
int save_host_config(const char *id, const char *rootpath, const char *hostconfigstr);
int save_config_v2_json(const char *id, const char *rootpath, const char *v2configstr);
int container_read_proc(uint32_t pid, container_pid_t *pid_info);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif

319
src/services/execution/manager/restore.c
View File

@ -28,6 +28,7 @@
#include "container_unix.h"
#include "error.h"
#include "image.h"
#include "runtime.h"
#ifdef ENABLE_OCI_IMAGE
#include "oci_images_store.h"
@ -36,15 +37,17 @@
#include "execution.h"
/* restore supervisor */
static int restore_supervisor(const char *id, const char *runtime, const char *statepath)
static int restore_supervisor(const container_t *cont)
{
int ret = 0;
int nret = 0;
int exit_fifo_fd = -1;
char container_state[PATH_MAX] = { 0 };
char pidfile[PATH_MAX] = { 0 };
char *exit_fifo = NULL;
container_pid_t *pid_info = NULL;
char *id = cont->common_config->id;
char *statepath = cont->state_path;
char *runtime = cont->runtime;
container_pid_t pid_info = { 0 };
nret = snprintf(container_state, sizeof(container_state), "%s/%s", statepath, id);
if (nret < 0 || (size_t)nret >= sizeof(container_state)) {
@ -67,23 +70,12 @@ static int restore_supervisor(const char *id, const char *runtime, const char *s
goto out;
}
nret = snprintf(pidfile, sizeof(pidfile), "%s/pid.file", container_state);
if (nret < 0 || (size_t)nret >= sizeof(pidfile)) {
close(exit_fifo_fd);
ERROR("Failed to sprintf pidfile");
ret = -1;
goto out;
}
pid_info.pid = cont->state->state->pid;
pid_info.ppid = cont->state->state->p_pid;
pid_info.start_time = cont->state->state->start_time;
pid_info.pstart_time = cont->state->state->p_start_time;
pid_info = container_read_pidfile(pidfile);
if (pid_info == NULL) {
close(exit_fifo_fd);
ERROR("Failed to get started container's pid info");
ret = -1;
goto out;
}
if (supervisor_add_exit_monitor(exit_fifo_fd, pid_info, id, runtime)) {
if (supervisor_add_exit_monitor(exit_fifo_fd, &pid_info, id, runtime)) {
ERROR("Failed to add exit monitor to supervisor");
ret = -1;
goto out;
@ -91,115 +83,31 @@ static int restore_supervisor(const char *id, const char *runtime, const char *s
out:
free(exit_fifo);
free(pid_info);
return ret;
}
static container_pid_t *container_read_proc(uint32_t pid)
{
container_pid_t *pid_info = NULL;
proc_t *proc_info = NULL;
if (pid == 0) {
goto out;
}
proc_info = util_get_process_proc_info((pid_t)pid);
if (proc_info == NULL) {
goto out;
}
pid_info = util_common_calloc_s(sizeof(container_pid_t));
if (pid_info == NULL) {
goto out;
}
pid_info->pid = proc_info->pid;
pid_info->start_time = proc_info->start_time;
out:
free(proc_info);
return pid_info;
}
/* post stopped container to gc */
static int post_stopped_container_to_gc(const char *id, const char *runtime, const char *statepath, uint32_t pid)
{
int ret = 0;
int nret = 0;
char container_state[PATH_MAX] = { 0 };
char pidfile[PATH_MAX] = { 0 };
container_pid_t *pid_info = NULL;
container_pid_t pid_info = { 0 };
nret = snprintf(container_state, sizeof(container_state), "%s/%s", statepath, id);
if (nret < 0 || (size_t)nret >= sizeof(container_state)) {
ERROR("Failed to sprintf container state %s/%s", statepath, id);
ret = -1;
goto out;
}
(void)container_read_proc(pid, &pid_info);
nret = snprintf(pidfile, sizeof(pidfile), "%s/pid.file", container_state);
if (nret < 0 || (size_t)nret >= sizeof(pidfile)) {
ERROR("Failed to sprintf pidfile");
ret = -1;
goto out;
}
pid_info = container_read_pidfile(pidfile);
if (pid_info == NULL) {
WARN("Failed to get started container's pid info, try to read proc filesystem");
pid_info = container_read_proc(pid);
if (pid_info == NULL) {
ERROR("Failed to get started container's pid info");
ret = -1;
goto out;
}
}
if (gc_add_container(id, runtime, pid_info)) {
if (gc_add_container(id, runtime, &pid_info)) {
ERROR("Failed to post container %s to garbage collector", id);
ret = -1;
goto out;
}
out:
free(pid_info);
return ret;
}
static container_pid_t *load_running_container_pid_info(const container_t *cont)
{
int nret = 0;
const char *id = cont->common_config->id;
char pidfile[PATH_MAX] = { 0 };
char container_state[PATH_MAX] = { 0 };
container_pid_t *pid_info = NULL;
nret = snprintf(container_state, sizeof(container_state), "%s/%s", cont->state_path, id);
if (nret < 0 || (size_t)nret >= sizeof(container_state)) {
ERROR("Failed to sprintf container_state for container %s", id);
goto out;
}
nret = snprintf(pidfile, sizeof(pidfile), "%s/pid.file", container_state);
if (nret < 0 || (size_t)nret >= sizeof(pidfile)) {
ERROR("Failed to sprintf pidfile");
goto out;
}
pid_info = container_read_pidfile(pidfile);
if (pid_info == NULL) {
goto out;
}
out:
return pid_info;
}
#ifdef ENABLE_OCI_IMAGE
static void post_nonexist_image_containers(const container_t *cont, Container_Status status,
const struct engine_container_summary_info *info)
const struct engine_container_status_info *info)
{
int nret;
const char *id = cont->common_config->id;
@ -267,50 +175,31 @@ out:
}
#endif
static void try_to_set_container_running(Container_Status status, const container_t *cont,
const container_pid_t *pid_info)
static bool is_same_process(const container_t *cont, const container_pid_t *pid_info)
{
int pid = 0;
pid = state_get_pid(cont->state);
if (status != CONTAINER_STATUS_RUNNING || pid != pid_info->pid) {
state_set_running(cont->state, pid_info, true);
if (pid_info->pid == cont->state->state->pid &&
pid_info->ppid == cont->state->state->p_pid &&
pid_info->start_time == cont->state->state->start_time &&
pid_info->pstart_time == cont->state->state->p_start_time) {
return true;
}
return false;
}
static void try_to_set_paused_container_pid(Container_Status status, const container_t *cont,
const container_pid_t *pid_info)
{
int pid = 0;
pid = state_get_pid(cont->state);
if (status != CONTAINER_STATUS_RUNNING || pid != pid_info->pid) {
if (status != CONTAINER_STATUS_RUNNING || !is_same_process(cont, pid_info)) {
state_set_running(cont->state, pid_info, false);
}
}
static int restore_check_id_valid(const char *id, const struct engine_container_summary_info *info,
size_t container_num)
static void try_to_set_container_running(Container_Status status, container_t *cont,
const container_pid_t *pid_info)
{
size_t i = 0;
if (id == NULL) {
ERROR("Cannot get container id from config v2");
return -1;
if (status != CONTAINER_STATUS_RUNNING || !is_same_process(cont, pid_info)) {
state_set_running(cont->state, pid_info, true);
}
for (i = 0; i < container_num; i++) {
if (strcmp(id, info[i].id) == 0) {
break;
}
}
if (i >= container_num) {
ERROR("Container %s is not in runtime container array", id);
return -1;
}
return (int)i;
}
static int restore_stopped_container(Container_Status status, const container_t *cont, bool *need_save)
@ -333,16 +222,19 @@ static int restore_stopped_container(Container_Status status, const container_t
}
static int restore_running_container(Container_Status status, container_t *cont,
const struct engine_container_summary_info *info)
const struct engine_container_status_info *info)
{
int ret = 0;
int nret = 0;
const char *id = cont->common_config->id;
container_pid_t *pid_info = NULL;
container_pid_t pid_info = { 0 };
pid_info = load_running_container_pid_info(cont);
if (pid_info == NULL) {
ERROR("Failed to restore container:%s due to unable to read container pid info", id);
int nret = post_stopped_container_to_gc(id, cont->runtime, cont->state_path, info->pid);
nret = container_read_proc(info->pid, &pid_info);
if (nret == 0) {
try_to_set_container_running(status, cont, &pid_info);
} else {
ERROR("Failed to restore container:%s due to unable to read container pid information", id);
nret = post_stopped_container_to_gc(id, cont->runtime, cont->state_path, 0);
if (nret != 0) {
ERROR("Failed to post container %s to garbage"
"collector, that may lost some resources"
@ -350,29 +242,30 @@ static int restore_running_container(Container_Status status, container_t *cont,
}
ret = -1;
goto out;
} else {
try_to_set_container_running(status, cont, pid_info);
}
container_reset_manually_stopped(cont);
out:
free(pid_info);
return ret;
}
static int restore_paused_container(Container_Status status, container_t *cont,
const struct engine_container_summary_info *info)
const struct engine_container_status_info *info)
{
int ret = 0;
int nret = 0;
const char *id = cont->common_config->id;
container_pid_t *pid_info = NULL;
container_pid_t pid_info = { 0 };
state_set_paused(cont->state);
pid_info = load_running_container_pid_info(cont);
if (pid_info == NULL) {
ERROR("Failed to restore container:%s due to unable to read container pid info", id);
int nret = post_stopped_container_to_gc(id, cont->runtime, cont->state_path, info->pid);
nret = container_read_proc(info->pid, &pid_info);
if (nret == 0) {
try_to_set_paused_container_pid(status, cont, &pid_info);
} else {
ERROR("Failed to restore container:%s due to unable to read container pid information", id);
nret = post_stopped_container_to_gc(id, cont->runtime, cont->state_path, 0);
if (nret != 0) {
ERROR("Failed to post container %s to garbage"
"collector, that may lost some resources"
@ -380,27 +273,31 @@ static int restore_paused_container(Container_Status status, container_t *cont,
}
ret = -1;
goto out;
} else {
try_to_set_paused_container_pid(status, cont, pid_info);
}
container_reset_manually_stopped(cont);
out:
free(pid_info);
return ret;
}
/* restore state */
static int restore_state(container_t *cont, const struct engine_container_summary_info *info, size_t container_num)
static int restore_state(container_t *cont)
{
int ret = 0;
int c_index = 0;
int nret = 0;
bool need_save = false;
const char *id = cont->common_config->id;
const char *runtime = cont->runtime;
rt_status_params_t params = { 0 };
struct engine_container_status_info real_status = { 0 };
Container_Status status = CONTAINER_STATUS_UNKNOWN;
c_index = restore_check_id_valid(id, info, container_num);
if (c_index < 0) {
params.rootpath = cont->root_path;
nret = runtime_status(id, runtime, &params, &real_status);
if (nret != 0) {
ERROR("Failed to restore container %s, due to can not load container status", id);
ret = -1;
goto out;
}
@ -411,29 +308,31 @@ static int restore_state(container_t *cont, const struct engine_container_summar
#ifdef ENABLE_OCI_IMAGE
if (check_container_image_exist(cont) != 0) {
ERROR("Failed to restore container:%s due to image not exist", id);
post_nonexist_image_containers(cont, status, &info[c_index]);
post_nonexist_image_containers(cont, status, &real_status);
ret = -1;
goto out;
}
#endif
if (info[c_index].status == ENGINE_CONTAINER_STATUS_STOPPED) {
if (real_status.status == ENGINE_CONTAINER_STATUS_STOPPED) {
ret = restore_stopped_container(status, cont, &need_save);
if (ret != 0) {
goto out;
}
} else if (info[c_index].status == ENGINE_CONTAINER_STATUS_RUNNING) {
ret = restore_running_container(status, cont, &info[c_index]);
} else if (real_status.status == ENGINE_CONTAINER_STATUS_RUNNING) {
ret = restore_running_container(status, cont, &real_status);
if (ret != 0) {
goto out;
}
} else if (info[c_index].status == ENGINE_CONTAINER_STATUS_PAUSED) {
ret = restore_paused_container(status, cont, &info[c_index]);
} else if (real_status.status == ENGINE_CONTAINER_STATUS_PAUSED) {
ret = restore_paused_container(status, cont, &real_status);
if (ret != 0) {
goto out;
}
} else {
ERROR("Container %s get invalid status %d", id, info[c_index].status);
ERROR("Container %s get invalid status %d", id, real_status.status);
ret = -1;
goto out;
}
if (is_removal_in_progress(cont->state)) {
@ -538,7 +437,7 @@ static void handle_restored_container()
id = cont->common_config->id;
if (is_running(cont->state)) {
if (restore_supervisor(id, cont->runtime, cont->state_path)) {
if (restore_supervisor(cont)) {
ERROR("Failed to restore %s supervisor", id);
}
init_health_monitor(id);
@ -563,8 +462,7 @@ static void handle_restored_container()
/* scan dir to add store */
static void scan_dir_to_add_store(const char *runtime, const char *rootpath, const char *statepath,
const size_t subdir_num, const char **subdir, const size_t container_num,
const struct engine_container_summary_info *info)
const size_t subdir_num, const char **subdir)
{
size_t i = 0;
container_t *cont = NULL;
@ -579,7 +477,7 @@ static void scan_dir_to_add_store(const char *runtime, const char *rootpath, con
goto error_load;
}
if (restore_state(cont, info, container_num)) {
if (restore_state(cont)) {
WARN("Failed to restore container %s state", subdir[i]);
goto error_load;
}
@ -609,83 +507,14 @@ error_load:
}
}
/* query all containers info */
static int query_all_containers_info(const char *runtime, struct engine_container_summary_info **container_summary,
size_t *container_num)
{
int ret = 0;
int container_nums = 0;
char *engine_path = NULL;
struct engine_operation *engine_ops = NULL;
if (runtime == NULL || container_summary == NULL || container_num == NULL) {
ERROR("invalid NULL param");
return -1;
}
engine_ops = engines_get_handler(runtime);
if (engine_ops == NULL || engine_ops->engine_get_all_containers_info_op == NULL) {
ERROR("Failed to get list op of engine %s", runtime);
ret = -1;
goto out;
}
engine_path = conf_get_routine_rootdir(runtime);
if (engine_path == NULL) {
ret = -1;
goto out;
}
container_nums = engine_ops->engine_get_all_containers_info_op(engine_path, container_summary);
if (container_nums < 0) {
ERROR("Engine %s get all containers info failed", runtime);
ret = -1;
goto out;
}
*container_num = (size_t)container_nums;
out:
free(engine_path);
if (engine_ops != NULL) {
engine_ops->engine_clear_errmsg_op();
}
return ret;
}
/* all containers info free */
static void all_containers_info_free(const char *runtime, struct engine_container_summary_info *container_summary,
size_t container_num)
{
struct engine_operation *engine_ops = NULL;
if (container_summary == NULL || runtime == NULL) {
return;
}
engine_ops = engines_get_handler(runtime);
if (engine_ops == NULL || engine_ops->engine_free_all_containers_info_op == NULL) {
ERROR("Failed to get free op of engine %s", runtime);
return;
}
engine_ops->engine_free_all_containers_info_op(container_summary, (int)container_num);
if (engine_ops->engine_clear_errmsg_op != NULL) {
engine_ops->engine_clear_errmsg_op();
}
return;
}
/* restore container by runtime */
static int restore_container_by_runtime(const char *runtime)
{
int ret = 0;
char *rootpath = NULL;
char *statepath = NULL;
size_t container_num = 0;
size_t subdir_num = 0;
char **subdir = NULL;
struct engine_container_summary_info *info = NULL;
rootpath = conf_get_routine_rootdir(runtime);
if (rootpath == NULL) {
@ -712,17 +541,9 @@ static int restore_container_by_runtime(const char *runtime)
goto out;
}
ret = query_all_containers_info(runtime, &info, &container_num);
if (ret < 0) {
ERROR("query all containers info failed");
ret = -1;
goto out;
}
scan_dir_to_add_store(runtime, rootpath, statepath, subdir_num, (const char **)subdir, container_num, info);
scan_dir_to_add_store(runtime, rootpath, statepath, subdir_num, (const char **)subdir);
out:
all_containers_info_free(runtime, info, container_num);
free(rootpath);
free(statepath);
util_free_array(subdir);