diff --git a/0001-fix-issues.patch b/0001-fix-issues.patch
new file mode 100644
index 0000000..ee6b360
--- /dev/null
+++ b/0001-fix-issues.patch
@@ -0,0 +1,1204 @@
+From 75c6db6769e7b08c1f842d6984fd3bfb341ab1ad Mon Sep 17 00:00:00 2001
+From: fly_1997 <flylove7@outlook.com>
+Date: Wed, 15 May 2024 17:01:35 +0800
+Subject: [PATCH] fix issues
+
+---
+ src/client/CMakeLists.txt               |  2 +-
+ src/client/arg_parse.cpp                | 23 ++++----
+ src/client/arg_parse.h                  | 22 ++++----
+ src/client/client.cpp                   | 31 +++++------
+ src/client/client.h                     | 10 ++--
+ src/client/cmd_handler.cpp              | 41 +++++++-------
+ src/client/cmd_handler.h                | 27 +++++-----
+ src/client/main.cpp                     |  1 -
+ src/client/tcp_socket.cpp               | 10 +---
+ src/client/tcp_socket.h                 |  6 ++-
+ src/common/CMakeLists.txt               |  2 +-
+ src/common/message_protocol.cpp         | 34 ++++++------
+ src/common/message_protocol.h           | 71 +++++++++++++------------
+ src/plugin_mgr/CMakeLists.txt           |  2 +-
+ src/plugin_mgr/config.cpp               | 16 +++---
+ src/plugin_mgr/config.h                 |  4 +-
+ src/plugin_mgr/dep_handler.h            |  4 +-
+ src/plugin_mgr/error_code.cpp           | 11 ++++
+ src/plugin_mgr/error_code.h             | 11 ++++
+ src/plugin_mgr/instance_run_handler.cpp | 48 ++++++++++++-----
+ src/plugin_mgr/main.cpp                 |  2 +-
+ src/plugin_mgr/message_manager.cpp      |  9 ++--
+ src/plugin_mgr/message_manager.h        |  5 +-
+ src/plugin_mgr/plugin.h                 |  4 +-
+ src/plugin_mgr/plugin_manager.cpp       | 37 +++++++------
+ 25 files changed, 243 insertions(+), 190 deletions(-)
+
+diff --git a/src/client/CMakeLists.txt b/src/client/CMakeLists.txt
+index d584d7d..11f9a5b 100644
+--- a/src/client/CMakeLists.txt
++++ b/src/client/CMakeLists.txt
+@@ -1,7 +1,7 @@
+ cmake_minimum_required (VERSION 3.22)
+ project(oeAware-client)
+ 
+-SET(CMAKE_CXX_FLAGS "-rdynamic -std=c++11 -g -Wl,-z,relro,-z,now")
++SET(CMAKE_CXX_FLAGS "-rdynamic -std=c++11 -g -Wl,-z,relro,-z,now -O2 -Wall -Wextra")
+ 
+ aux_source_directory(. SOURCE)
+ include_directories(../common)
+diff --git a/src/client/arg_parse.cpp b/src/client/arg_parse.cpp
+index 805f5a7..947c4c4 100644
+--- a/src/client/arg_parse.cpp
++++ b/src/client/arg_parse.cpp
+@@ -13,7 +13,7 @@
+ #include <iostream>
+ #include <getopt.h>
+ 
+-const std::string ArgParse::OPT_STRING = "Qqd:t:l:r:e:";
++const std::string ArgParse::OPT_STRING = "Qqd:t:l:r:e:i:";
+ const struct option ArgParse::long_options[] = {
+     {"help", no_argument, NULL, 'h'},
+     {"load", required_argument, NULL, 'l'},
+@@ -58,7 +58,7 @@ void ArgParse::print_help() {
+            "    -Q                      query all instances dependencies.\n"
+            "    --query-dep [instance]  query the instance dependency.\n"
+            "    --list                  the list of supported plugins.\n"
+-           "    --install [plugin]      install plugin from the list.\n"
++           "    -i|--install [plugin]   install plugin from the list.\n"
+            "    --help                  show this help message.\n";
+ }
+ 
+@@ -69,7 +69,6 @@ void ArgParse::init_opts() {
+     opts.insert('Q');
+     opts.insert('e');
+     opts.insert('d');
+-    opts.insert('L');
+     opts.insert('i');
+     opts.insert('t');
+ }
+@@ -90,13 +89,18 @@ int ArgParse::init(int argc, char *argv[]) {
+                 help = true;
+                 break;
+             case '?': {
+-                std::string err;
+-                err += optopt;
++                std::string opt_string;
++                if (optind == argc) {
++                    opt_string += argv[optind - 1];    
++                } else {
++                    opt_string += argv[optind];
++                }
+                 if (!opts.count(optopt)) {
+-                    arg_error("unknown option '-" + err  + "'.");
++                    arg_error("unknown option '" + opt_string  + "'.");
+                 } else{
+-                    arg_error("option -" + err  + " requires an argument.");
++                    arg_error("option " + opt_string  + " requires an argument.");
+                 }
++                break;
+             }
+             default: {
+                 if (opt == 'l' || opt == 'r' || opt == 'q' || opt == 'Q' || opt == 'e' || opt == 'd'  || opt == 'L' || opt == 'i') {
+@@ -109,19 +113,20 @@ int ArgParse::init(int argc, char *argv[]) {
+                         set_arg(optarg);
+                     }
+                 } 
++                break;
+             }
+                 
+         }
+     }
+     if (cmd == 'l' && type.empty()) {
+-        arg_error("option '-t' is required.");
++        arg_error("missing arguments.");
+     }
+     if (help) {
+         print_help();
+         exit(EXIT_SUCCESS);
+     }
+     if (cmd < 0) {
+-        arg_error("no option.");
++        arg_error("option error.");
+     }
+     return cmd;
+ }
+diff --git a/src/client/arg_parse.h b/src/client/arg_parse.h
+index 682f0e5..6a0a25b 100644
+--- a/src/client/arg_parse.h
++++ b/src/client/arg_parse.h
+@@ -18,20 +18,20 @@ class ArgParse {
+ public:
+     static void arg_error(const std::string &msg);
+     static void print_help();
+-    int init(int argc, char *argv[]);
+-    void init_opts();
+-    void set_type(char* _type);
+-    void set_arg(char* _arg);
+-    std::string get_type() const {
+-        return this->type;
++    static int init(int argc, char *argv[]);
++    static void init_opts();
++    static void set_type(char* _type);
++    static void set_arg(char* _arg);
++    static std::string get_type() {
++        return type;
+     }
+-    std::string get_arg() const {
+-        return this->arg;
++    static std::string get_arg() {
++        return arg;
+     }
+ private:
+-    std::string arg;
+-    std::string type;
+-    std::unordered_set<char> opts;
++    static std::string arg;
++    static std::string type;
++    static std::unordered_set<char> opts;
+     static const std::string OPT_STRING;
+     static const int MAX_OPT_SIZE = 20;
+     static const struct option long_options[MAX_OPT_SIZE];
+diff --git a/src/client/client.cpp b/src/client/client.cpp
+index 39a0072..afaa189 100644
+--- a/src/client/client.cpp
++++ b/src/client/client.cpp
+@@ -11,18 +11,23 @@
+  ******************************************************************************/
+ #include "client.h"
+ 
++std::string ArgParse::arg;
++std::string ArgParse::type;
++std::unordered_set<char> ArgParse::opts;
++
+ void Client::cmd_groups_init() {
+-    cmd_handler_groups.insert(std::make_pair('l', new LoadHandler()));
+-    cmd_handler_groups.insert(std::make_pair('q', new QueryHandler()));
+-    cmd_handler_groups.insert(std::make_pair('r', new RemoveHandler()));
+-    cmd_handler_groups.insert(std::make_pair('Q', new QueryTopHandler()));
+-    cmd_handler_groups.insert(std::make_pair('e', new EnabledHandler()));
+-    cmd_handler_groups.insert(std::make_pair('d', new DisabledHandler()));
+-    cmd_handler_groups.insert(std::make_pair('L', new ListHandler()));
+-    cmd_handler_groups.insert(std::make_pair('i', new InstallHandler(arg_parse.get_arg())));
++    cmd_handler_groups.insert(std::make_pair('l', std::make_shared<LoadHandler>()));
++    cmd_handler_groups.insert(std::make_pair('q', std::make_shared<QueryHandler>()));
++    cmd_handler_groups.insert(std::make_pair('r', std::make_shared<RemoveHandler>()));
++    cmd_handler_groups.insert(std::make_pair('Q', std::make_shared<QueryTopHandler>()));
++    cmd_handler_groups.insert(std::make_pair('e', std::make_shared<EnabledHandler>()));
++    cmd_handler_groups.insert(std::make_pair('d', std::make_shared<DisabledHandler>()));
++    cmd_handler_groups.insert(std::make_pair('L', std::make_shared<ListHandler>()));
++    cmd_handler_groups.insert(std::make_pair('i', std::make_shared<InstallHandler>()));
+ }
++
+ bool Client::init(int argc, char *argv[]) {
+-    if ((cmd = arg_parse.init(argc, argv)) < 0) {
++    if ((cmd = ArgParse::init(argc, argv)) < 0) {
+         return false;
+     }
+     cmd_groups_init();
+@@ -34,8 +39,8 @@ void Client::run_cmd() {
+     Msg res;
+     MessageHeader header;
+     this->cmd_handler = cmd_handler_groups[cmd];
+-    this->cmd_handler->handler(arg_parse, msg);
+-    if(!this->tcp_socket.send_msg(msg)) {
++    this->cmd_handler->handler(msg);
++    if(!this->tcp_socket.send_msg(msg, header)) {
+         return;
+     }
+     if (!this->tcp_socket.recv_msg(res, header)) {
+@@ -43,7 +48,3 @@ void Client::run_cmd() {
+     }
+     this->cmd_handler->res_handler(res);
+ }
+-
+-void Client::close() {
+-    tcp_socket.clear();
+-}
+diff --git a/src/client/client.h b/src/client/client.h
+index 9e60251..82cf613 100644
+--- a/src/client/client.h
++++ b/src/client/client.h
+@@ -14,14 +14,11 @@
+ #include "tcp_socket.h"
+ #include "cmd_handler.h"
+ #include <unordered_map>
++#include <memory>
+ 
+ class Client {
+ public:
+     Client() : cmd_handler(nullptr) { }
+-    ~Client() {
+-        if (cmd_handler)
+-            delete cmd_handler;
+-    }
+     bool init(int argc, char *argv[]);
+     void run_cmd();
+     void close();
+@@ -30,9 +27,8 @@ private:
+     
+     int cmd;
+     TcpSocket tcp_socket;
+-    ArgParse arg_parse;
+-    CmdHandler *cmd_handler;
+-    std::unordered_map<int, CmdHandler*> cmd_handler_groups;
++    std::shared_ptr<CmdHandler> cmd_handler;
++    std::unordered_map<int, std::shared_ptr<CmdHandler>> cmd_handler_groups;
+ };
+ 
+ #endif // !CLIENT_H
+diff --git a/src/client/cmd_handler.cpp b/src/client/cmd_handler.cpp
+index b410968..6f3f760 100644
+--- a/src/client/cmd_handler.cpp
++++ b/src/client/cmd_handler.cpp
+@@ -15,16 +15,16 @@
+ 
+ std::unordered_set<std::string> LoadHandler::types = {"collector", "scenario", "tune"};
+ 
+-void LoadHandler::check(const std::string &arg, const std::string &type) {
++void LoadHandler::check(const std::string &type) {
+     if (!types.count(type)) {
+         ArgParse::arg_error("type '" + type + "' is not supported.");
+     }
+ }
+ 
+-void LoadHandler::handler(const ArgParse &arg_parse, Msg &msg) {
+-    std::string arg = arg_parse.get_arg();
+-    std::string type = arg_parse.get_type();
+-    check(arg, type);
++void LoadHandler::handler(Msg &msg) {
++    std::string arg = ArgParse::get_arg();
++    std::string type = ArgParse::get_type();
++    check(type);
+     msg.add_payload(arg);
+     msg.add_payload(type);
+     msg.set_opt(Opt::LOAD);
+@@ -47,8 +47,8 @@ void LoadHandler::res_handler(Msg &msg) {
+     
+ }
+ 
+-void QueryHandler::handler(const ArgParse &arg_parse, Msg &msg) {
+-    std::string arg = arg_parse.get_arg();
++void QueryHandler::handler(Msg &msg) {
++    std::string arg = ArgParse::get_arg();
+     if (arg.empty()) {
+         msg.set_opt(Opt::QUERY_ALL);
+     } else {
+@@ -80,8 +80,8 @@ void QueryHandler::res_handler(Msg &msg) {
+     print_format();
+ }
+ 
+-void RemoveHandler::handler(const ArgParse &arg_parse, Msg &msg) {
+-    std::string arg = arg_parse.get_arg();
++void RemoveHandler::handler(Msg &msg) {
++    std::string arg = ArgParse::get_arg();
+     msg.add_payload(arg);
+     msg.set_opt(Opt::REMOVE);
+ }
+@@ -106,8 +106,8 @@ void write_to_file(const std::string &file_name, const std::string &text) {
+     out.close(); 
+ }
+ 
+-void QueryTopHandler::handler(const ArgParse &arg_parse, Msg &msg) {
+-    std::string arg = arg_parse.get_arg();
++void QueryTopHandler::handler(Msg &msg) {
++    std::string arg = ArgParse::get_arg();
+     if (arg.empty()) { 
+         msg.set_opt(Opt::QUERY_ALL_TOP);
+     } else {
+@@ -127,8 +127,8 @@ void QueryTopHandler::res_handler(Msg &msg) {
+     std::cout << "Generate dependencies graph dep.png.\n";
+ }
+ 
+-void EnabledHandler::handler(const ArgParse &arg_parse, Msg &msg) {
+-    std::string arg = arg_parse.get_arg();
++void EnabledHandler::handler(Msg &msg) {
++    std::string arg = ArgParse::get_arg();
+     msg.add_payload(arg);
+     msg.set_opt(Opt::ENABLED);
+ }
+@@ -141,8 +141,8 @@ void EnabledHandler::res_handler(Msg &msg) {
+     }
+ }
+ 
+-void DisabledHandler::handler(const ArgParse &arg_parse, Msg &msg) {
+-    std::string arg = arg_parse.get_arg();
++void DisabledHandler::handler(Msg &msg) {
++    std::string arg = ArgParse::get_arg();
+     msg.add_payload(arg);
+     msg.set_opt(Opt::DISABLED);
+ }
+@@ -155,7 +155,7 @@ void DisabledHandler::res_handler(Msg &msg) {
+     }
+ }
+ 
+-void ListHandler::handler(const ArgParse &arg_parse, Msg &msg) {
++void ListHandler::handler(Msg &msg) {
+     msg.set_opt(Opt::LIST);
+ }
+ 
+@@ -172,18 +172,19 @@ void ListHandler::res_handler(Msg &msg) {
+     std::cout << "------------------------------------------------------------\n";
+ }
+ 
+-void InstallHandler::handler(const ArgParse &arg_parse, Msg &msg) {
+-    std::string arg = arg_parse.get_arg();
++void InstallHandler::handler(Msg &msg) {
++    std::string arg = ArgParse::get_arg();
+     msg.set_opt(Opt::DOWNLOAD);
+     msg.add_payload(arg);
+ }
+ 
+ void InstallHandler::res_handler(Msg &msg) {
++    std::string arg = ArgParse::get_arg();
+     if (msg.get_opt() == Opt::RESPONSE_ERROR) {
+-        std::cout << "Download failed, because " << msg.payload(0) <<": " << this->arg.c_str() << '\n';
++        std::cout << "Download failed, because " << msg.payload(0) <<": " << arg.c_str() << '\n';
+         return;
+     }
+-    std::string path = this->arg;
++    std::string path = arg;
+     std::string url = msg.payload(0);
+     if (!download(url, path)) {
+         std::cout << "Download failed, please check url or your network.\n";
+diff --git a/src/client/cmd_handler.h b/src/client/cmd_handler.h
+index 1b6f1c1..2e32098 100644
+--- a/src/client/cmd_handler.h
++++ b/src/client/cmd_handler.h
+@@ -19,23 +19,25 @@
+ 
+ class CmdHandler {
+ public:
+-    virtual void handler(const ArgParse &arg_parse, Msg &msg) = 0;
++    virtual void handler(Msg &msg) = 0;
+     virtual void res_handler(Msg &msg) = 0;
+-private:
++
++    static ArgParse &arg_parse;
+ };
+ 
+ class LoadHandler : public CmdHandler {
+ public:
+-    void handler(const ArgParse &arg_parse, Msg &msg) override;
++    // LoadHandler(const ArgParse &arg_parse) { }
++    void handler(Msg &msg) override;
+     void res_handler(Msg &msg) override;
+ private:
+-    void check(const std::string &arg, const std::string &type);
++    void check(const std::string &type);
+     static std::unordered_set<std::string> types; 
+ };
+ 
+ class QueryHandler : public CmdHandler {
+ public:
+-    void handler(const ArgParse &arg_parse, Msg &msg) override;
++    void handler(Msg &msg) override;
+     void res_handler(Msg &msg) override;
+ private:
+     void print_format();
+@@ -43,42 +45,39 @@ private:
+ 
+ class RemoveHandler : public CmdHandler {
+ public:
+-    void handler(const ArgParse &arg_parse, Msg &msg) override;
++    void handler(Msg &msg) override;
+     void res_handler(Msg &msg) override;
+ };
+ 
+ 
+ class QueryTopHandler : public CmdHandler {
+ public:
+-    void handler(const ArgParse &arg_parse, Msg &msg) override;
++    void handler(Msg &msg) override;
+     void res_handler(Msg &msg) override;
+ };
+ 
+ class EnabledHandler : public CmdHandler {
+ public:
+-    void handler(const ArgParse &arg_parse, Msg &msg) override;
++    void handler(Msg &msg) override;
+     void res_handler(Msg &msg) override;
+ };
+ 
+ class DisabledHandler : public CmdHandler {
+ public:
+-    void handler(const ArgParse &arg_parse, Msg &msg) override;
++    void handler(Msg &msg) override;
+     void res_handler(Msg &msg) override;
+ };
+ 
+ class ListHandler : public CmdHandler {
+ public:
+-    void handler(const ArgParse &arg_parse, Msg &msg) override;
++    void handler(Msg &msg) override;
+     void res_handler(Msg &msg) override;
+ };
+ 
+ class InstallHandler : public CmdHandler {
+ public:
+-    InstallHandler(const std::string &arg) : arg(arg) { }
+-    void handler(const ArgParse &arg_parse, Msg &msg) override;
++    void handler(Msg &msg) override;
+     void res_handler(Msg &msg) override;
+-private:
+-    std::string arg;
+ };
+ 
+ #endif // !CLIENT_CMD_HANDLER_H
+diff --git a/src/client/main.cpp b/src/client/main.cpp
+index 62b7ca5..e47c523 100644
+--- a/src/client/main.cpp
++++ b/src/client/main.cpp
+@@ -17,6 +17,5 @@ int main(int argc, char *argv[]) {
+         exit(EXIT_FAILURE);
+     }
+     client.run_cmd();       
+-    client.close();
+     return 0;
+ }
+diff --git a/src/client/tcp_socket.cpp b/src/client/tcp_socket.cpp
+index d0721cc..7781183 100644
+--- a/src/client/tcp_socket.cpp
++++ b/src/client/tcp_socket.cpp
+@@ -15,7 +15,7 @@
+ 
+ bool TcpSocket::recv_msg(Msg &res, MessageHeader &header) {
+     MessageProtocol proto;
+-    if (handle_request(stream, proto) < 0) {
++    if (!handle_request(stream, proto)) {
+         printf("can't connect to server!\n");
+         return false;
+     }
+@@ -24,8 +24,7 @@ bool TcpSocket::recv_msg(Msg &res, MessageHeader &header) {
+     return true;
+ }
+ 
+-bool TcpSocket::send_msg(Msg &msg) {
+-    MessageHeader header;
++bool TcpSocket::send_msg(Msg &msg, MessageHeader &header) {
+     if (!send_response(stream, msg, header)) {
+         return false;
+     }
+@@ -52,13 +51,8 @@ bool TcpSocket::init() {
+         return -1;
+     }
+     if (file_connect(SOCK_PATH.c_str()) < 0) {
+-        close(sock);
+         return false;
+     }
+     stream.set_sock(sock);
+     return true;
+ }
+-
+-void TcpSocket::clear() {
+-    close(sock);
+-}
+\ No newline at end of file
+diff --git a/src/client/tcp_socket.h b/src/client/tcp_socket.h
+index fa0073b..1a3dfef 100644
+--- a/src/client/tcp_socket.h
++++ b/src/client/tcp_socket.h
+@@ -16,11 +16,13 @@
+ class TcpSocket {
+ public:
+     TcpSocket() { }
++    ~TcpSocket() {
++        close(sock);
++    }
+     bool recv_msg(Msg &res, MessageHeader &header);
+-    bool send_msg(Msg &msg);
++    bool send_msg(Msg &msg, MessageHeader &header);
+     int file_connect(const char *name);
+     bool init();
+-    void clear();
+ private:
+     int sock;
+     SocketStream stream;
+diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
+index dece483..ac7525b 100644
+--- a/src/common/CMakeLists.txt
++++ b/src/common/CMakeLists.txt
+@@ -2,7 +2,7 @@ cmake_minimum_required (VERSION 3.22)
+ project(common)
+ 
+ aux_source_directory(. SOURCE)
+-SET(CMAKE_CXX_FLAGS "-rdynamic -std=c++11 -g -Wl,-z,relro,-z,now")
++SET(CMAKE_CXX_FLAGS "-rdynamic -std=c++11 -g -Wl,-z,relro,-z,now -Wall -Wextra -fPIC -O2")
+ 
+ 
+ include_directories(/usr/include/yaml-cpp)
+diff --git a/src/common/message_protocol.cpp b/src/common/message_protocol.cpp
+index 05d437c..a813a6c 100644
+--- a/src/common/message_protocol.cpp
++++ b/src/common/message_protocol.cpp
+@@ -13,7 +13,7 @@
+ #include <iostream>
+ 
+ template <typename T>
+-inline ssize_t handle_EINTR(T fn) {
++inline ssize_t handle_error(T fn) {
+     ssize_t res = 0;
+     while (true) {
+         res = fn();
+@@ -25,27 +25,27 @@ inline ssize_t handle_EINTR(T fn) {
+     return res;
+ }
+ 
+-inline ssize_t read_socket(int sock, void *ptr, size_t size, int flags) {
+-    return handle_EINTR([&]() {
+-        return recv(sock, ptr, size, flags);
++inline ssize_t read_socket(int sock, void *buf, size_t size, int flags) {
++    return handle_error([&]() {
++        return recv(sock, buf, size, flags);
+     });
+ }
+ 
+-inline ssize_t send_socket(int sock, const void *ptr, size_t size, int flags) {
+-    return handle_EINTR([&]() {
+-        return send(sock, ptr, size, flags);
++inline ssize_t send_socket(int sock, const void *buf, size_t size, int flags) {
++    return handle_error([&]() {
++        return send(sock, buf, size, flags);
+     });
+ }
+ 
+-ssize_t SocketStream::read(char *ptr, size_t size) {
++ssize_t SocketStream::read(char *buf, size_t size) {
+     if (read_buff_off < read_buff_content_size) {
+         auto remaining_size = read_buff_content_size - read_buff_off;
+         if (size <= remaining_size) {
+-            memcpy(ptr, read_buff.data() + read_buff_off, size);
++            memcpy(buf, read_buff.data() + read_buff_off, size);
+             read_buff_off += size;
+             return size;
+         } else {
+-            memcpy(ptr, read_buff.data() + read_buff_off, remaining_size);
++            memcpy(buf, read_buff.data() + read_buff_off, remaining_size);
+             read_buff_off += remaining_size;
+             return remaining_size;
+         }
+@@ -56,22 +56,22 @@ ssize_t SocketStream::read(char *ptr, size_t size) {
+         auto n = read_socket(sock, read_buff.data(), MAX_BUFF_SIZE, 0);
+         if (n <= 0) {
+             return n;
+-        } else if (n < size) {
+-            memcpy(ptr, read_buff.data(), n);
++        } else if (static_cast<size_t>(n) < size) {
++            memcpy(buf, read_buff.data(), n);
+             return n;
+         } else {
+-            memcpy(ptr, read_buff.data(), size);
++            memcpy(buf, read_buff.data(), size);
+             read_buff_off = size;
+             read_buff_content_size = n;
+             return size;
+         }
+     } else {
+-        return read_socket(sock, ptr, size, 0);
++        return read_socket(sock, buf, size, 0);
+     }
+ }
+ 
+-ssize_t SocketStream::write(const char *ptr, size_t size) {
+-    return send_socket(sock, ptr, size, 0);
++ssize_t SocketStream::write(const char *buf, size_t size) {
++    return send_socket(sock, buf, size, 0);
+ }
+ 
+ static std::string to_hex(size_t x) {
+@@ -80,7 +80,7 @@ static std::string to_hex(size_t x) {
+     ss << std::hex << std::uppercase << x;
+     result = ss.str();
+     std::string zero = "";
+-    for (int i = result.length(); i < sizeof(size_t); ++i) {
++    for (size_t i = result.length(); i < sizeof(size_t); ++i) {
+         zero += "0";
+     }
+     result = zero + result;
+diff --git a/src/common/message_protocol.h b/src/common/message_protocol.h
+index 3771298..b2c3c0d 100644
+--- a/src/common/message_protocol.h
++++ b/src/common/message_protocol.h
+@@ -44,38 +44,39 @@ enum class Opt {
+ };
+ 
+ class Msg {
+-    private:
+-        friend class boost::serialization::access;
+-        template <typename Archive>
+-        void serialize(Archive &ar, const unsigned int version) {
+-            ar & _opt;
+-            ar & _payload;
+-        }
+-    public:
+-        int payload_size() const {
+-            return this->_payload.size();
+-        }
+-        std::string payload(int id) const {
+-            return this->_payload[id];
+-        }
+-        Opt opt() {
+-            return this->_opt;
+-        }
+-        void add_payload(std::string &context) {
+-            this->_payload.emplace_back(context);
+-        }
+-        void add_payload(std::string &&context) {
+-            this->_payload.emplace_back(context);
+-        }
+-        void set_opt(Opt opt) {
+-            this->_opt = opt;
+-        }
+-        Opt get_opt() const {
+-            return this->_opt;
+-        }
+-    private:
+-        Opt _opt;
+-        std::vector<std::string> _payload;
++private:
++    friend class boost::serialization::access;
++    template <typename Archive>
++    void serialize(Archive &ar, const unsigned int version) {
++        ar & _opt;
++        ar & _payload;
++    }
++public:
++    Msg() { }
++    int payload_size() const {
++        return this->_payload.size();
++    }
++    std::string payload(int id) const {
++        return this->_payload[id];
++    }
++    Opt opt() {
++        return this->_opt;
++    }
++    void add_payload(std::string &context) {
++        this->_payload.emplace_back(context);
++    }
++    void add_payload(std::string &&context) {
++        this->_payload.emplace_back(context);
++    }
++    void set_opt(Opt opt) {
++        this->_opt = opt;
++    }
++    Opt get_opt() const {
++        return this->_opt;
++    }
++private:
++    Opt _opt;
++    std::vector<std::string> _payload;
+ };
+ 
+ class MessageHeader {
+@@ -86,6 +87,7 @@ private:
+         ar & code;
+     }
+ public:
++    MessageHeader() { }
+     void set_state_code(int code) {
+         this->code = code;
+     }
+@@ -109,8 +111,8 @@ class SocketStream {
+ public:
+     SocketStream() : read_buff(MAX_BUFF_SIZE, 0) { }
+     SocketStream(int sock) : sock(sock), read_buff(MAX_BUFF_SIZE, 0) { }
+-    ssize_t read(char *ptr, size_t size);
+-    ssize_t write(const char *ptr, size_t size);
++    ssize_t read(char *buf, size_t size);
++    ssize_t write(const char *buf, size_t size);
+     void set_sock(int sock) {
+         this->sock = sock;
+     }
+@@ -135,7 +137,6 @@ std::string encode(const T &msg) {
+ 
+ template<typename T> 
+ int decode(T &msg, const std::string &content) {
+-    int len = 0;
+     try {
+         std::stringstream ss(content);
+         boost::archive::binary_iarchive ia(ss);
+diff --git a/src/plugin_mgr/CMakeLists.txt b/src/plugin_mgr/CMakeLists.txt
+index a32c800..8642a63 100644
+--- a/src/plugin_mgr/CMakeLists.txt
++++ b/src/plugin_mgr/CMakeLists.txt
+@@ -1,7 +1,7 @@
+ cmake_minimum_required (VERSION 3.22)
+ project(oeAware-server)
+ 
+-SET(CMAKE_CXX_FLAGS "-rdynamic -std=c++11 -g -Wl,-z,relro,-z,now")
++SET(CMAKE_CXX_FLAGS "-rdynamic -std=c++11 -g -Wl,-z,relro,-z,now -Wall -Wextra -O2")
+ 
+ if("${OEAWARE_DEBUG}" EQUAL 1)
+ add_definitions(-DOEAWARE_DEBUG)
+diff --git a/src/plugin_mgr/config.cpp b/src/plugin_mgr/config.cpp
+index f50399b..588eda0 100644
+--- a/src/plugin_mgr/config.cpp
++++ b/src/plugin_mgr/config.cpp
+@@ -32,11 +32,11 @@ bool create_dir(const std::string &path) {
+ 
+ bool check_plugin_list(YAML::Node plugin_list_item) {
+     if (plugin_list_item["name"].IsNull()) {
+-        std::cerr << "Warn: null name in plugin_list.\n";
++        std::cerr << "WARN: null name in plugin_list.\n";
+         return false;
+     }
+     if (plugin_list_item["url"].IsNull()) {
+-        std::cerr << "Warn: null url in plugin_list.\n";
++        std::cerr << "WARN: null url in plugin_list.\n";
+         return false;
+     }
+     return true;
+@@ -60,7 +60,7 @@ bool Config::load(const std::string path) {
+         if (!node["plugin_list"].IsNull()) {
+             YAML::Node plugin_list = node["plugin_list"];
+             if (plugin_list.IsSequence()) {
+-                for (int i = 0; i < plugin_list.size(); ++i) {
++                for (size_t i = 0; i < plugin_list.size(); ++i) {
+                     if (!check_plugin_list(plugin_list[i])){
+                         continue;
+                     }
+@@ -81,15 +81,14 @@ bool Config::load(const std::string path) {
+         if (!node["enable_list"].IsNull()) {
+             YAML::Node enable_list = node["enable_list"];
+             if (enable_list.IsSequence()) {
+-                for (int i = 0; i < enable_list.size(); ++i) {
+-                    YAML::Node plugin = enable_list[i]["name"];
++                for (size_t i = 0; i < enable_list.size(); ++i) {
+                     std::string name = enable_list[i]["name"].as<std::string>();
+                     YAML::Node instances = enable_list[i]["instances"];
+                     EnableItem enable_item(name);
+-                    if (instances.IsNull()) {
++                    if (!instances.IsDefined() || instances.IsNull()) {
+                         enable_item.set_enabled(true);
+                     } else {
+-                        for (int j = 0; j < instances.size(); ++j) {
++                        for (size_t j = 0; j < instances.size(); ++j) {
+                             std::string i_name = instances[j].as<std::string>();
+                             enable_item.add_instance(i_name);
+                         }
+@@ -118,6 +117,9 @@ std::string get_path(PluginType type) {
+         case PluginType::TUNE: {
+             return DEFAULT_TUNE_PATH;
+         }
++        default: {
++            break;
++        }
+     }
+     return "";
+ }
+\ No newline at end of file
+diff --git a/src/plugin_mgr/config.h b/src/plugin_mgr/config.h
+index 6d0ee4d..c2d1f37 100644
+--- a/src/plugin_mgr/config.h
++++ b/src/plugin_mgr/config.h
+@@ -72,9 +72,9 @@ public:
+         return this->name;
+     }
+ private:
+-    bool enabled;
+-    std::string name;
+     std::vector<std::string> instance;
++    std::string name;
++    bool enabled;
+ };
+ 
+ class Config {
+diff --git a/src/plugin_mgr/dep_handler.h b/src/plugin_mgr/dep_handler.h
+index 76abf49..b81d574 100644
+--- a/src/plugin_mgr/dep_handler.h
++++ b/src/plugin_mgr/dep_handler.h
+@@ -33,8 +33,8 @@ struct Node {
+     int cnt; 
+     int real_cnt; 
+     bool state; // dependency closed-loop
+-    Node() : next(nullptr), head(nullptr), state(true), cnt(0), real_cnt(0) {}
+-    Node(std::string name): name(name), next(nullptr), head(nullptr), state(true), cnt(0), real_cnt(0) {}
++    Node() : next(nullptr), head(nullptr), cnt(0), real_cnt(0), state(true) {}
++    Node(std::string name): next(nullptr), head(nullptr), name(name), cnt(0), real_cnt(0), state(true) {}
+ };
+ 
+ class DepHandler {
+diff --git a/src/plugin_mgr/error_code.cpp b/src/plugin_mgr/error_code.cpp
+index 30cc4f8..09f0eb9 100644
+--- a/src/plugin_mgr/error_code.cpp
++++ b/src/plugin_mgr/error_code.cpp
+@@ -1,3 +1,14 @@
++/******************************************************************************
++ * Copyright (c) 2024 Huawei Technologies Co., Ltd.
++ * oeAware is licensed under Mulan PSL v2.
++ * You can use this software according to the terms and conditions of the Mulan PSL v2.
++ * You may obtain a copy of Mulan PSL v2 at:
++ *          http://license.coscl.org.cn/MulanPSL2
++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
++ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
++ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
++ * See the Mulan PSL v2 for more details.
++ ******************************************************************************/
+ #include "error_code.h"
+ 
+ const std::unordered_map<ErrorCode, std::string> ErrorText::error_codes = {
+diff --git a/src/plugin_mgr/error_code.h b/src/plugin_mgr/error_code.h
+index 7c06054..dd028f3 100644
+--- a/src/plugin_mgr/error_code.h
++++ b/src/plugin_mgr/error_code.h
+@@ -1,3 +1,14 @@
++/******************************************************************************
++ * Copyright (c) 2024 Huawei Technologies Co., Ltd.
++ * oeAware is licensed under Mulan PSL v2.
++ * You can use this software according to the terms and conditions of the Mulan PSL v2.
++ * You may obtain a copy of Mulan PSL v2 at:
++ *          http://license.coscl.org.cn/MulanPSL2
++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
++ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
++ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
++ * See the Mulan PSL v2 for more details.
++ ******************************************************************************/
+ #ifndef PLUGIN_MGR_ERROR_CODE_H
+ #define PLUGIN_MGR_ERROR_CODE_H
+ #include <unordered_map>
+diff --git a/src/plugin_mgr/instance_run_handler.cpp b/src/plugin_mgr/instance_run_handler.cpp
+index 862e806..8ba10db 100644
+--- a/src/plugin_mgr/instance_run_handler.cpp
++++ b/src/plugin_mgr/instance_run_handler.cpp
+@@ -18,12 +18,18 @@ static void* get_ring_buf(std::shared_ptr<Instance> instance) {
+         return nullptr;
+     }
+     switch (instance->get_type()) {
+-        case PluginType::COLLECTOR:
++        case PluginType::COLLECTOR: {
+             return (std::dynamic_pointer_cast<CollectorInstance>(instance))->get_interface()->get_ring_buf();
+-        case PluginType::SCENARIO:
++        }
++        case PluginType::SCENARIO: {
+             return (std::dynamic_pointer_cast<ScenarioInstance>(instance))->get_interface()->get_ring_buf();
+-        case PluginType::TUNE:
++        }
++        case PluginType::TUNE: {
+             break;
++        }
++        default: {
++            break;
++        }
+     }
+     return nullptr;
+ }
+@@ -34,7 +40,7 @@ static void reflash_ring_buf(std::shared_ptr<Instance> instance) {
+ 
+ void InstanceRunHandler::run_aware(std::shared_ptr<Instance> instance, std::vector<std::string> &deps) {
+     void *a[MAX_DEPENDENCIES_SIZE];
+-    for (int i = 0; i < deps.size(); ++i) {
++    for (size_t i = 0; i < deps.size(); ++i) {
+         std::shared_ptr<Instance> ins = memory_store.get_instance(deps[i]);
+         a[i] = get_ring_buf(ins);
+     }
+@@ -43,7 +49,7 @@ void InstanceRunHandler::run_aware(std::shared_ptr<Instance> instance, std::vect
+ 
+ void InstanceRunHandler::run_tune(std::shared_ptr<Instance> instance, std::vector<std::string> &deps) {
+     void *a[MAX_DEPENDENCIES_SIZE];
+-    for (int i = 0; i < deps.size(); ++i) {
++    for (size_t i = 0; i < deps.size(); ++i) {
+         std::shared_ptr<Instance> ins = memory_store.get_instance(deps[i]);
+         a[i] = get_ring_buf(ins);
+     }
+@@ -52,36 +58,48 @@ void InstanceRunHandler::run_tune(std::shared_ptr<Instance> instance, std::vecto
+ 
+ void InstanceRunHandler::insert_instance(std::shared_ptr<Instance> instance) {
+     switch (instance->get_type()) {
+-        case PluginType::COLLECTOR:
++        case PluginType::COLLECTOR: {
+             collector[instance->get_name()] = instance;
+             (std::dynamic_pointer_cast<CollectorInstance>(instance))->get_interface()->enable();
+             break;
+-        case PluginType::SCENARIO:
++        }
++        case PluginType::SCENARIO: {
+             scenario[instance->get_name()] = instance;
+             (std::dynamic_pointer_cast<ScenarioInstance>(instance))->get_interface()->enable();
+             break;
+-        case PluginType::TUNE:
++        }
++        case PluginType::TUNE: {
+             tune[instance->get_name()] = instance;
+             (std::dynamic_pointer_cast<TuneInstance>(instance))->get_interface()->enable();
+             break;
++        }
++        default: {
++            break;
++        }
+     }
+     INFO("[PluginManager] " << instance->get_name() << " instance insert into running queue.");
+ }
+ 
+ void InstanceRunHandler::delete_instance(std::shared_ptr<Instance> instance) {
+     switch (instance->get_type()) {
+-        case PluginType::COLLECTOR:
++        case PluginType::COLLECTOR: {
+             collector.erase(instance->get_name());
+             (std::dynamic_pointer_cast<CollectorInstance>(instance))->get_interface()->disable();
+             break;
+-        case PluginType::SCENARIO:
++        }
++        case PluginType::SCENARIO: {
+             scenario.erase(instance->get_name());
+             (std::dynamic_pointer_cast<ScenarioInstance>(instance))->get_interface()->disable();
+             break;
+-        case PluginType::TUNE:
++        }
++        case PluginType::TUNE: {
+             tune.erase(instance->get_name());
+             (std::dynamic_pointer_cast<TuneInstance>(instance))->get_interface()->disable();
+             break;
++        }
++        default: {
++            break;
++        }
+     }
+     INFO("[PluginManager] " << instance->get_name() << " instance delete from running queue.");
+ }
+@@ -91,12 +109,14 @@ void InstanceRunHandler::handle_instance() {
+     while(this->recv_queue_try_pop(msg)){
+         std::shared_ptr<Instance> instance = msg.get_instance();
+         switch (msg.get_type()){
+-            case RunType::ENABLED:
++            case RunType::ENABLED: {
+                 insert_instance(std::move(instance));
+                 break;
+-            case RunType::DISABLED:
++            }
++            case RunType::DISABLED: {
+                 delete_instance(std::move(instance));
+                 break;
++            }
+         }
+     }
+ }
+@@ -107,7 +127,7 @@ static std::vector<std::string> get_deps(std::shared_ptr<Instance> instance) {
+     std::string deps = (t_instance)->get_interface()->get_dep();
+     std::string dep = "";
+     std::vector<std::string> vec;
+-    for (int i = 0; i < deps.length(); ++i) {
++    for (size_t i = 0; i < deps.length(); ++i) {
+         if (deps[i] != '-') {
+             dep += deps[i];
+         }else {
+diff --git a/src/plugin_mgr/main.cpp b/src/plugin_mgr/main.cpp
+index 92f48bb..4e6acdc 100644
+--- a/src/plugin_mgr/main.cpp
++++ b/src/plugin_mgr/main.cpp
+@@ -48,7 +48,7 @@ int main(int argc, char **argv) {
+     SafeQueue<Message> res_msg;
+     INFO("[MessageManager] Start message manager!");
+     MessageManager message_manager(&handler_msg, &res_msg);
+-    message_manager.init(&config);
++    message_manager.init();
+     message_manager.run();
+     INFO("[PluginManager] Start plugin manager!");
+     PluginManager plugin_manager(config, handler_msg, res_msg);
+diff --git a/src/plugin_mgr/message_manager.cpp b/src/plugin_mgr/message_manager.cpp
+index f081f20..815122c 100644
+--- a/src/plugin_mgr/message_manager.cpp
++++ b/src/plugin_mgr/message_manager.cpp
+@@ -44,7 +44,6 @@ bool TcpSocket::init() {
+         return false;
+     }
+     if (domain_listen(path.c_str()) < 0) {
+-        close(sock);
+         return false;
+     }
+     epfd = epoll_create(1);
+@@ -52,6 +51,9 @@ bool TcpSocket::init() {
+     ev.events = EPOLLIN;
+     ev.data.fd = sock;
+     int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, sock, &ev);
++    if (ret < 0) {
++        return false;
++    }
+     return true;
+ 
+ }
+@@ -64,7 +66,7 @@ static void send_msg(Msg &msg, SafeQueue<Message> *handler_msg) {
+     }
+     handler_msg->push(message);
+ }
+-static void recv_msg(Msg &msg, MessageHeader &header, SafeQueue<Message> *res_msg) {
++static void recv_msg(Msg &msg, SafeQueue<Message> *res_msg) {
+     Message res;
+     res_msg->wait_and_pop(res);
+     msg.set_opt(res.get_opt());
+@@ -76,7 +78,6 @@ static void recv_msg(Msg &msg, MessageHeader &header, SafeQueue<Message> *res_ms
+ void TcpSocket::serve_accept(SafeQueue<Message> *handler_msg, SafeQueue<Message> *res_msg){
+     struct epoll_event evs[MAX_EVENT_SIZE];
+     int sz = sizeof(evs) / sizeof(struct epoll_event);
+-    char buf[MAX_RECV_BUFF_SIZE];
+     while (true) {
+         int num = epoll_wait(epfd, evs, sz, -1);
+         for (int i = 0; i < num; ++i) {
+@@ -102,7 +103,7 @@ void TcpSocket::serve_accept(SafeQueue<Message> *handler_msg, SafeQueue<Message>
+                 }
+                 decode(client_msg, msg_protocol.body);
+                 send_msg(client_msg, handler_msg);
+-                recv_msg(internal_msg, header, res_msg);
++                recv_msg(internal_msg, res_msg);
+                 if (!send_response(stream, internal_msg, header)) {
+                     WARN("[MessageManager] send msg to client failed!");
+                 }
+diff --git a/src/plugin_mgr/message_manager.h b/src/plugin_mgr/message_manager.h
+index 4cd7311..416be48 100644
+--- a/src/plugin_mgr/message_manager.h
++++ b/src/plugin_mgr/message_manager.h
+@@ -62,6 +62,9 @@ private:
+ class TcpSocket {
+ public:
+     TcpSocket() {}
++    ~TcpSocket() {
++        close(sock);
++    }
+     bool init();
+     void serve_accept(SafeQueue<Message> *handler_msg, SafeQueue<Message> *res_msg);    
+ private:
+@@ -77,7 +80,7 @@ public:
+         this->handler_msg = handler_msg;
+         this->res_msg = res_msg;
+     }
+-    void init(Config *config){
++    void init(){
+        this->tcp_socket = new TcpSocket();
+     }
+     void run();
+diff --git a/src/plugin_mgr/plugin.h b/src/plugin_mgr/plugin.h
+index a2a1815..d59ab8a 100644
+--- a/src/plugin_mgr/plugin.h
++++ b/src/plugin_mgr/plugin.h
+@@ -148,10 +148,10 @@ public:
+         return handler;
+     }
+ private:
+-    void *handler;
+     std::vector<std::shared_ptr<Instance>> instances;
+-    PluginType type;
+     std::string name;
++    PluginType type;
++    void *handler;
+ };
+ 
+ #endif 
+diff --git a/src/plugin_mgr/plugin_manager.cpp b/src/plugin_mgr/plugin_manager.cpp
+index 77acc40..5324512 100644
+--- a/src/plugin_mgr/plugin_manager.cpp
++++ b/src/plugin_mgr/plugin_manager.cpp
+@@ -34,7 +34,7 @@ ErrorCode PluginManager::remove(const std::string &name) {
+     }
+     std::shared_ptr<Plugin> plugin = memory_store.get_plugin(name);
+     std::vector<std::string> instance_names;
+-    for (int i = 0; i < plugin->get_instance_len(); ++i) {
++    for (size_t i = 0; i < plugin->get_instance_len(); ++i) {
+         std::shared_ptr<Instance> instance = plugin->get_instance(i);
+         std::string iname = instance->get_name();
+         if (instance->get_enabled()) {
+@@ -57,7 +57,7 @@ ErrorCode PluginManager::query_all_plugins(std::string &res) {
+     std::vector<std::shared_ptr<Plugin>> all_plugins = memory_store.get_all_plugins();
+     for (auto &p : all_plugins) {
+         res += p->get_name() + "\n";
+-        for (int i = 0; i < p->get_instance_len(); ++i) {
++        for (size_t i = 0; i < p->get_instance_len(); ++i) {
+             std::string info = p->get_instance(i)->get_info();
+             res += "\t" + info + "\n";
+         }
+@@ -71,7 +71,7 @@ ErrorCode PluginManager::query_plugin(const std::string &name, std::string &res)
+     }
+     std::shared_ptr<Plugin> plugin = memory_store.get_plugin(name);
+     res += name + "\n";
+-    for (int i = 0; i < plugin->get_instance_len(); ++i) {
++    for (size_t i = 0; i < plugin->get_instance_len(); ++i) {
+         std::string info = plugin->get_instance(i)->get_info();
+         res += "\t" + info + "\n";
+     }
+@@ -92,7 +92,6 @@ int PluginManager::load_dl_instance(std::shared_ptr<Plugin> plugin, T **interfac
+ 
+ template<typename T>
+ std::vector<std::string> get_dep(T *interface) {
+-    int dep_len = 0;
+     char *deps = interface->get_dep();
+     std::vector<std::string> res;
+     std::string dep;
+@@ -152,12 +151,16 @@ bool PluginManager::load_instance(std::shared_ptr<Plugin> plugin) {
+             save_instance<ScenarioInterface, ScenarioInstance>(plugin, interface_list, len);
+             break;
+         }
+-        case PluginType::TUNE:
++        case PluginType::TUNE: {
+             TuneInterface *interface_list = nullptr;
+             len = load_dl_instance<TuneInterface>(plugin, &interface_list);
+             if (len == -1) return false;
+             save_instance<TuneInterface, TuneInstance>(plugin, interface_list, len);
+             break;
++        }
++        default: {
++            return false;
++        }
+     }
+     update_instance_state();
+     return true;
+@@ -211,9 +214,13 @@ std::string generate_dot(MemoryStore &memory_store, const std::vector<std::vecto
+         if (vec.size() == 1) {
+             continue;
+         }
+-        instance = memory_store.get_instance(vec[1]);
+-        sub_graph[instance->get_plugin_name()].insert(vec[1]);
+-        res += vec[0] + "->"  + vec[1] + ";";
++        if (memory_store.is_instance_exist(vec[1])) {
++            instance = memory_store.get_instance(vec[1]);
++            sub_graph[instance->get_plugin_name()].insert(vec[1]);
++        } else {
++            res += vec[1] + "[label=\"(missing)\\n" + vec[1] + "\", fontcolor=red];\n";
++        }
++        res += vec[0] + "->"  + vec[1] + ";\n";
+     }
+     int id = 0;
+     for (auto &p : sub_graph) {
+@@ -339,7 +346,7 @@ ErrorCode PluginManager::download(const std::string &name, std::string &res) {
+ }
+ 
+ void PluginManager::pre_enable() {
+-    for (int i = 0; i < config.get_enable_list_size(); ++i) {
++    for (size_t i = 0; i < config.get_enable_list_size(); ++i) {
+         EnableItem item = config.get_enable_list(i);
+         if (item.get_enabled()) {
+             std::string name = item.get_name();
+@@ -348,11 +355,11 @@ void PluginManager::pre_enable() {
+                 continue;
+             }
+             std::shared_ptr<Plugin> plugin = memory_store.get_plugin(name);
+-            for (int j = 0; j < plugin->get_instance_len(); ++j) {
++            for (size_t j = 0; j < plugin->get_instance_len(); ++j) {
+                 instance_enabled(plugin->get_instance(j)->get_name());
+             }
+         } else {
+-            for (int j = 0; j < item.get_instance_size(); ++j) {
++            for (size_t j = 0; j < item.get_instance_size(); ++j) {
+                 std::string name = item.get_instance_name(j);
+                 if (!memory_store.is_instance_exist(name)) {
+                     WARN("[PluginManager] instance " << name << " cannot be enabled, because it does not exist.");
+@@ -410,7 +417,7 @@ void* PluginManager::get_data_buffer(std::string name) {
+ std::string PluginManager::instance_dep_check(const std::string &name) {
+     std::shared_ptr<Plugin> plugin = memory_store.get_plugin(name);
+     std::string res;
+-    for (int i = 0; i < plugin->get_instance_len(); ++i) {
++    for (size_t i = 0; i < plugin->get_instance_len(); ++i) {
+         std::string instance_name = plugin->get_instance(i)->get_name();
+         std::vector<std::vector<std::string>> query;
+         dep_handler.query_node(instance_name, query);
+@@ -422,9 +429,9 @@ std::string PluginManager::instance_dep_check(const std::string &name) {
+             }
+         }
+         if (!lack.empty()) {
+-            for (int i = 0; i < lack.size(); ++i) {
+-                res += "\t" + lack[i];
+-                if (i != lack.size() - 1) res += '\n';
++            for (size_t j = 0; j < lack.size(); ++j) {
++                res += "\t" + lack[j];
++                if (j != lack.size() - 1) res += '\n';
+             }
+         }
+     }
+-- 
+2.33.0
+
diff --git a/oeAware-manager.spec b/oeAware-manager.spec
index 682947b..70d3e2b 100644
--- a/oeAware-manager.spec
+++ b/oeAware-manager.spec
@@ -1,10 +1,11 @@
 Name:       oeAware-manager
 Version:    v1.0.1
-Release:    1
+Release:    2
 Summary:    OeAware server and client 
 License:    MulanPSL2
 URL:        https://gitee.com/openeuler/%{name}
 Source0:    %{name}-%{version}.tar.gz
+Patch1:     0001-fix-issues.patch
 
 BuildRequires: cmake make gcc-c++
 BuildRequires: boost-devel
@@ -48,6 +49,10 @@ install -D -p -m 0644 oeaware.service %{buildroot}%{_unitdir}/oeaware.service
 %attr(0644, root, root) %{_unitdir}/oeaware.service
 
 %changelog
+* Wed May 15 2024 fly_1997 <flylove7@outlook.com> -v1.0.1-2
+- fix pre-enable failed, dependencies missing error, memory leak
+- fix warning message
+
 * Sat May 11 2024 fly_1997 <flylove7@outlook.com> -v1.0.1-1
 - update version to v1.0.1