milvus-io
/
milvus
mirror of https://github.com/milvus-io/milvus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Caiyd 090 rename config (#2340) 

* rename config items

Signed-off-by: yudong.cai <yudong.cai@zilliz.com>

* update config unittest

Signed-off-by: yudong.cai <yudong.cai@zilliz.com>

* fix clang-format

Signed-off-by: yudong.cai <yudong.cai@zilliz.com>

* update config unittest

Signed-off-by: yudong.cai <yudong.cai@zilliz.com>

* update log rotate default value

Signed-off-by: yudong.cai <yudong.cai@zilliz.com>

* update parameter usage in LogUtil.cpp (#3)

Signed-off-by: wxyu <xy.wang@zilliz.com>

* retry ci

Signed-off-by: yudong.cai <yudong.cai@zilliz.com>

* fix ut

Signed-off-by: yudong.cai <yudong.cai@zilliz.com>

Co-authored-by: JinHai-CN <hai.jin@zilliz.com>
Co-authored-by: Wang XiangYu <scsven@qq.com>
pull/2349/head
Cai Yudong 2020-05-15 01:57:18 +08:00 committed by GitHub
parent 860cc97a06
commit eba33cc46d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 470 additions and 280 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -70,7 +70,6 @@ Please mark all change in change log and use the issue from GitHub
## Task
# Milvus 0.8.0 (2020-04-15)
## Bug

18
core/conf/demo/server_config.yaml
View File

@ -68,8 +68,8 @@ db_config:
# secondary_path | A semicolon-separated list of secondary directories used | Path | |
# | to save vector data and index data. | | |
#----------------------+------------------------------------------------------------+------------+-----------------+
# file_cleanup_timeout | time gap between soft-delete and hard-delete | Integer | 10 (s) |
# | range [0, 3600] | | |
# file_cleanup_timeout | The time gap between marking a file as 'deleted' and | Integer | 10 (s) |
# | physically deleting this file from disk, range [0, 3600] | | |
#----------------------+------------------------------------------------------------+------------+-----------------+
storage_config:
primary_path: /var/lib/milvus
@ -206,14 +206,12 @@ wal_config:
#----------------------+------------------------------------------------------------+------------+-----------------+
# fatal.enable | Whether to enable fatal level logging in Milvus. | Boolean | true |
#----------------------+------------------------------------------------------------+------------+-----------------+
# path | Location of logs files. | String | |
# path | Absolute path to the folder holding the log files. | String | |
#----------------------+------------------------------------------------------------+------------+-----------------+
# max_log_file_size | Max size of a single log file. After exceeding this value, | Integer | 256 (MB) |
# | rename this file to xxx.log.n, means the nth file. | | |
# max_log_file_size | The maximum size of each log file, size range [512, 4096] | Integer | 1024 (MB) |
#----------------------+------------------------------------------------------------+------------+-----------------+
# delete_exceeds | Milvus will keep up to ${delete_exceeds} log files per | Integer | 10 |
# | level. For example, after xxx.log.11 file is generated, | | |
# | the xxx.log.1 file will be deleted. | | |
# log_rotate_num | The maximum number of log files that Milvus keeps for each | Integer | 0 |
# | logging level, num range [0, 1024], 0 means unlimited. | | |
#----------------------+------------------------------------------------------------+------------+-----------------+
logs:
trace.enable: true
@ -223,6 +221,6 @@ logs:
error.enable: true
fatal.enable: true
path: /var/lib/milvus/logs
max_log_file_size: 256
delete_exceeds: 10
max_log_file_size: 1024
log_rotate_num: 0

18
core/conf/server_config.template
View File

@ -68,8 +68,8 @@ db_config:
# secondary_path | A semicolon-separated list of secondary directories used | Path | |
# | to save vector data and index data. | | |
#----------------------+------------------------------------------------------------+------------+-----------------+
# file_cleanup_timeout | time gap between soft-delete and hard-delete | Integer | 10 (s) |
# | range [0, 3600] | | |
# file_cleanup_timeout | The time gap between marking a file as 'deleted' and | Integer | 10 (s) |
# | physically deleting this file from disk, range [0, 3600] | | |
#----------------------+------------------------------------------------------------+------------+-----------------+
storage_config:
primary_path: @MILVUS_DB_PATH@
@ -206,14 +206,12 @@ wal_config:
#----------------------+------------------------------------------------------------+------------+-----------------+
# fatal.enable | Whether to enable fatal level logging in Milvus. | Boolean | true |
#----------------------+------------------------------------------------------------+------------+-----------------+
# path | Location of logs files. | String | |
# path | Absolute path to the folder holding the log files. | String | |
#----------------------+------------------------------------------------------------+------------+-----------------+
# max_log_file_size | Max size of a single log file. After exceeding this value, | Integer | 256 (MB) |
# | rename this file to xxx.log.n, means the nth file. | | |
# max_log_file_size | The maximum size of each log file, size range [512, 4096] | Integer | 1024 (MB) |
#----------------------+------------------------------------------------------------+------------+-----------------+
# delete_exceeds | Milvus will keep up to ${delete_exceeds} log files per | Integer | 10 |
# | level. For example, after xxx.log.11 file is generated, | | |
# | the xxx.log.1 file will be deleted. | | |
# log_rotate_num | The maximum number of log files that Milvus keeps for each | Integer | 0 |
# | logging level, num range [0, 1024], 0 means unlimited. | | |
#----------------------+------------------------------------------------------------+------------+-----------------+
logs:
trace.enable: true
@ -223,6 +221,6 @@ logs:
error.enable: true
fatal.enable: true
path: @MILVUS_DB_PATH@/logs
max_log_file_size: 256
delete_exceeds: 10
max_log_file_size: 1024
log_rotate_num: 0

118
core/src/config/Config.cpp
View File

@ -76,6 +76,8 @@ const char* CONFIG_STORAGE_SECONDARY_PATH = "secondary_path";
const char* CONFIG_STORAGE_SECONDARY_PATH_DEFAULT = "";
const char* CONFIG_STORAGE_FILE_CLEANUP_TIMEOUT = "file_cleanup_timeout";
const char* CONFIG_STORAGE_FILE_CLEANUP_TIMEOUT_DEFAULT = "10";
const int64_t CONFIG_STORAGE_FILE_CLEANUP_TIMEOUT_MIN = 0;
const int64_t CONFIG_STORAGE_FILE_CLEANUP_TIMEOUT_MAX = 3600;
// const char* CONFIG_STORAGE_S3_ENABLE = "s3_enable";
// const char* CONFIG_STORAGE_S3_ENABLE_DEFAULT = "false";
// const char* CONFIG_STORAGE_S3_ADDRESS = "s3_address";
@ -150,8 +152,8 @@ const char* CONFIG_WAL_RECOVERY_ERROR_IGNORE = "recovery_error_ignore";
const char* CONFIG_WAL_RECOVERY_ERROR_IGNORE_DEFAULT = "true";
const char* CONFIG_WAL_BUFFER_SIZE = "buffer_size";
const char* CONFIG_WAL_BUFFER_SIZE_DEFAULT = "256";
const int64_t CONFIG_WAL_BUFFER_SIZE_MAX = 4096;
const int64_t CONFIG_WAL_BUFFER_SIZE_MIN = 64;
const int64_t CONFIG_WAL_BUFFER_SIZE_MAX = 4096;
const char* CONFIG_WAL_WAL_PATH = "wal_path";
const char* CONFIG_WAL_WAL_PATH_DEFAULT = "/tmp/milvus/wal";
@ -172,13 +174,13 @@ const char* CONFIG_LOGS_FATAL_ENABLE_DEFAULT = "true";
const char* CONFIG_LOGS_PATH = "path";
const char* CONFIG_LOGS_PATH_DEFAULT = "/tmp/milvus/logs";
const char* CONFIG_LOGS_MAX_LOG_FILE_SIZE = "max_log_file_size";
const char* CONFIG_LOGS_MAX_LOG_FILE_SIZE_DEFAULT = "256";
const int64_t CONFIG_LOGS_MAX_LOG_FILE_SIZE_MAX = 512;
const int64_t CONFIG_LOGS_MAX_LOG_FILE_SIZE_MIN = 64;
const char* CONFIG_LOGS_DELETE_EXCEEDS = "delete_exceeds";
const char* CONFIG_LOGS_DELETE_EXCEEDS_DEFAULT = "10";
const int64_t CONFIG_LOGS_DELETE_EXCEEDS_MAX = 4096;
const int64_t CONFIG_LOGS_DELETE_EXCEEDS_MIN = 1;
const char* CONFIG_LOGS_MAX_LOG_FILE_SIZE_DEFAULT = "1024";
const int64_t CONFIG_LOGS_MAX_LOG_FILE_SIZE_MIN = 512;
const int64_t CONFIG_LOGS_MAX_LOG_FILE_SIZE_MAX = 4096;
const char* CONFIG_LOGS_LOG_ROTATE_NUM = "log_rotate_num";
const char* CONFIG_LOGS_LOG_ROTATE_NUM_DEFAULT = "0";
const int64_t CONFIG_LOGS_LOG_ROTATE_NUM_MIN = 0;
const int64_t CONFIG_LOGS_LOG_ROTATE_NUM_MAX = 1024;
constexpr int64_t GB = 1UL << 30;
constexpr int32_t PORT_NUMBER_MIN = 1024;
@ -416,8 +418,8 @@ Config::ValidateConfig() {
int64_t logs_max_log_file_size;
STATUS_CHECK(GetLogsMaxLogFileSize(logs_max_log_file_size));
int64_t delete_exceeds;
STATUS_CHECK(GetLogsDeleteExceeds(delete_exceeds));
int64_t logs_log_rotate_num;
STATUS_CHECK(GetLogsLogRotateNum(logs_log_rotate_num));
return Status::OK();
}
@ -493,7 +495,7 @@ Config::ResetDefaultConfig() {
STATUS_CHECK(SetLogsFatalEnable(CONFIG_LOGS_FATAL_ENABLE_DEFAULT));
STATUS_CHECK(SetLogsPath(CONFIG_LOGS_PATH_DEFAULT));
STATUS_CHECK(SetLogsMaxLogFileSize(CONFIG_LOGS_MAX_LOG_FILE_SIZE_DEFAULT));
STATUS_CHECK(SetLogsDeleteExceeds(CONFIG_LOGS_DELETE_EXCEEDS_DEFAULT));
STATUS_CHECK(SetLogsLogRotateNum(CONFIG_LOGS_LOG_ROTATE_NUM_DEFAULT));
return Status::OK();
}
@ -635,6 +637,28 @@ Config::SetConfigCli(const std::string& parent_key, const std::string& child_key
} else {
status = Status(SERVER_UNEXPECTED_ERROR, invalid_node_str);
}
} else if (parent_key == CONFIG_LOGS) {
if (child_key == CONFIG_LOGS_TRACE_ENABLE) {
status = SetLogsTraceEnable(value);
} else if (child_key == CONFIG_LOGS_DEBUG_ENABLE) {
status = SetLogsDebugEnable(value);
} else if (child_key == CONFIG_LOGS_INFO_ENABLE) {
status = SetLogsInfoEnable(value);
} else if (child_key == CONFIG_LOGS_WARNING_ENABLE) {
status = SetLogsWarningEnable(value);
} else if (child_key == CONFIG_LOGS_ERROR_ENABLE) {
status = SetLogsErrorEnable(value);
} else if (child_key == CONFIG_LOGS_FATAL_ENABLE) {
status = SetLogsFatalEnable(value);
} else if (child_key == CONFIG_LOGS_PATH) {
status = SetLogsPath(value);
} else if (child_key == CONFIG_LOGS_MAX_LOG_FILE_SIZE) {
status = SetLogsMaxLogFileSize(value);
} else if (child_key == CONFIG_LOGS_LOG_ROTATE_NUM) {
status = SetLogsLogRotateNum(value);
} else {
status = Status(SERVER_UNEXPECTED_ERROR, invalid_node_str);
}
}
if (status.ok()) {
@ -1086,23 +1110,18 @@ Config::CheckStorageConfigSecondaryPath(const std::string& value) {
Status
Config::CheckStorageConfigFileCleanupTimeout(const std::string& value) {
auto status = Status::OK();
if (value.empty()) {
return status;
}
if (!ValidationUtil::ValidateStringIsNumber(value).ok()) {
std::string msg = "Invalid file cleanup timeout: " + value +
std::string msg = "Invalid file_cleanup_timeout: " + value +
". Possible reason: storage_config.file_cleanup_timeout is not a positive integer.";
return Status(SERVER_INVALID_ARGUMENT, msg);
} else {
const int64_t min = 0, max = 3600;
int64_t file_cleanup_timeout = std::stoll(value);
if (file_cleanup_timeout < min || file_cleanup_timeout > max) {
std::string msg = "Invalid file cleanup timeout: " + value +
if (file_cleanup_timeout < CONFIG_STORAGE_FILE_CLEANUP_TIMEOUT_MIN ||
file_cleanup_timeout > CONFIG_STORAGE_FILE_CLEANUP_TIMEOUT_MAX) {
std::string msg = "Invalid file_cleanup_timeout: " + value +
". Possible reason: storage_config.file_cleanup_timeout is not in range [" +
std::to_string(min) + ", " + std::to_string(max) + "].";
std::to_string(CONFIG_STORAGE_FILE_CLEANUP_TIMEOUT_MIN) + ", " +
std::to_string(CONFIG_STORAGE_FILE_CLEANUP_TIMEOUT_MIN) + "].";
return Status(SERVER_INVALID_ARGUMENT, msg);
}
}
@ -1673,19 +1692,38 @@ Config::CheckLogsMaxLogFileSize(const std::string& value) {
std::string msg = "Invalid max_log_file_size: " + value +
". Possible reason: logs.max_log_file_size is not a positive integer.";
return Status(SERVER_INVALID_ARGUMENT, msg);
} else {
int64_t max_log_file_size = std::stoll(value);
if (max_log_file_size < CONFIG_LOGS_MAX_LOG_FILE_SIZE_MIN ||
max_log_file_size > CONFIG_LOGS_MAX_LOG_FILE_SIZE_MAX) {
std::string msg = "Invalid max_log_file_size: " + value +
". Possible reason: logs.max_log_file_size is not in range [" +
std::to_string(CONFIG_LOGS_MAX_LOG_FILE_SIZE_MIN) + ", " +
std::to_string(CONFIG_LOGS_MAX_LOG_FILE_SIZE_MAX) + "].";
return Status(SERVER_INVALID_ARGUMENT, msg);
}
}
return Status::OK();
}
Status
Config::CheckLogsDeleteExceeds(const std::string& value) {
Config::CheckLogsLogRotateNum(const std::string& value) {
auto exist_error = !ValidationUtil::ValidateStringIsNumber(value).ok();
fiu_do_on("check_logs_delete_exceeds_fail", exist_error = true);
fiu_do_on("check_logs_log_rotate_num_fail", exist_error = true);
if (exist_error) {
std::string msg = "Invalid max_log_file_size: " + value +
". Possible reason: logs.max_log_file_size is not a positive integer.";
std::string msg =
"Invalid log_rotate_num: " + value + ". Possible reason: logs.log_rotate_num is not a positive integer.";
return Status(SERVER_INVALID_ARGUMENT, msg);
} else {
int64_t log_rotate_num = std::stoll(value);
if (log_rotate_num < CONFIG_LOGS_LOG_ROTATE_NUM_MIN || log_rotate_num > CONFIG_LOGS_LOG_ROTATE_NUM_MAX) {
std::string msg = "Invalid log_rotate_num: " + value +
". Possible reason: logs.log_rotate_num is not in range [" +
std::to_string(CONFIG_LOGS_LOG_ROTATE_NUM_MIN) + ", " +
std::to_string(CONFIG_LOGS_LOG_ROTATE_NUM_MAX) + "].";
return Status(SERVER_INVALID_ARGUMENT, msg);
}
}
return Status::OK();
}
@ -2221,30 +2259,14 @@ Config::GetLogsMaxLogFileSize(int64_t& value) {
std::string str = GetConfigStr(CONFIG_LOGS, CONFIG_LOGS_MAX_LOG_FILE_SIZE, CONFIG_LOGS_MAX_LOG_FILE_SIZE_DEFAULT);
STATUS_CHECK(CheckLogsMaxLogFileSize(str));
value = std::stoll(str);
if (value == 0) {
// OFF
} else if (value > CONFIG_LOGS_MAX_LOG_FILE_SIZE_MAX) {
value = CONFIG_LOGS_MAX_LOG_FILE_SIZE_MAX;
} else if (value < CONFIG_LOGS_MAX_LOG_FILE_SIZE_MIN) {
value = CONFIG_LOGS_MAX_LOG_FILE_SIZE_MIN;
}
return Status::OK();
}
Status
Config::GetLogsDeleteExceeds(int64_t& value) {
std::string str = GetConfigStr(CONFIG_LOGS, CONFIG_LOGS_DELETE_EXCEEDS, CONFIG_LOGS_DELETE_EXCEEDS_DEFAULT);
STATUS_CHECK(CheckLogsDeleteExceeds(str));
Config::GetLogsLogRotateNum(int64_t& value) {
std::string str = GetConfigStr(CONFIG_LOGS, CONFIG_LOGS_LOG_ROTATE_NUM, CONFIG_LOGS_LOG_ROTATE_NUM_DEFAULT);
STATUS_CHECK(CheckLogsLogRotateNum(str));
value = std::stoll(str);
if (value == 0) {
// OFF
} else if (value > CONFIG_LOGS_DELETE_EXCEEDS_MAX) {
value = CONFIG_LOGS_DELETE_EXCEEDS_MAX;
} else if (value < CONFIG_LOGS_DELETE_EXCEEDS_MIN) {
value = CONFIG_LOGS_DELETE_EXCEEDS_MIN;
}
return Status::OK();
}
@ -2578,9 +2600,9 @@ Config::SetLogsMaxLogFileSize(const std::string& value) {
}
Status
Config::SetLogsDeleteExceeds(const std::string& value) {
STATUS_CHECK(CheckLogsDeleteExceeds(value));
return SetConfigValueInMem(CONFIG_LOGS, CONFIG_LOGS_DELETE_EXCEEDS, value);
Config::SetLogsLogRotateNum(const std::string& value) {
STATUS_CHECK(CheckLogsLogRotateNum(value));
return SetConfigValueInMem(CONFIG_LOGS, CONFIG_LOGS_LOG_ROTATE_NUM, value);
}
} // namespace server

20
core/src/config/Config.h
View File

@ -63,6 +63,8 @@ extern const char* CONFIG_STORAGE_PRIMARY_PATH_DEFAULT;
extern const char* CONFIG_STORAGE_SECONDARY_PATH;
extern const char* CONFIG_STORAGE_SECONDARY_PATH_DEFAULT;
extern const char* CONFIG_STORAGE_FILE_CLEANUP_TIMEOUT;
extern const int64_t CONFIG_STORAGE_FILE_CLEANUP_TIMEOUT_MIN;
extern const int64_t CONFIG_STORAGE_FILE_CLEANUP_TIMEOUT_MAX;
// extern const char* CONFIG_STORAGE_S3_ENABLE;
// extern const char* CONFIG_STORAGE_S3_ENABLE_DEFAULT;
// extern const char* CONFIG_STORAGE_S3_ADDRESS;
@ -133,8 +135,8 @@ extern const char* CONFIG_WAL_RECOVERY_ERROR_IGNORE;
extern const char* CONFIG_WAL_RECOVERY_ERROR_IGNORE_DEFAULT;
extern const char* CONFIG_WAL_BUFFER_SIZE;
extern const char* CONFIG_WAL_BUFFER_SIZE_DEFAULT;
extern const int64_t CONFIG_WAL_BUFFER_SIZE_MAX;
extern const int64_t CONFIG_WAL_BUFFER_SIZE_MIN;
extern const int64_t CONFIG_WAL_BUFFER_SIZE_MAX;
extern const char* CONFIG_WAL_WAL_PATH;
extern const char* CONFIG_WAL_WAL_PATH_DEFAULT;
@ -155,12 +157,12 @@ extern const char* CONFIG_LOGS_FATAL_ENABLE_DEFAULT;
extern const char* CONFIG_LOGS_PATH;
extern const char* CONFIG_LOGS_MAX_LOG_FILE_SIZE;
extern const char* CONFIG_LOGS_MAX_LOG_FILE_SIZE_DEFAULT;
extern const int64_t CONFIG_LOGS_MAX_LOG_FILE_SIZE_MAX;
extern const int64_t CONFIG_LOGS_MAX_LOG_FILE_SIZE_MIN;
extern const char* CONFIG_LOGS_DELETE_EXCEEDS;
extern const char* CONFIG_LOGS_DELETE_EXCEEDS_DEFAULT;
extern const int64_t CONFIG_LOGS_DELETE_EXCEEDS_MAX;
extern const int64_t CONFIG_LOGS_DELETE_EXCEEDS_MIN;
extern const int64_t CONFIG_LOGS_MAX_LOG_FILE_SIZE_MAX;
extern const char* CONFIG_LOGS_LOG_ROTATE_NUM;
extern const char* CONFIG_LOGS_LOG_ROTATE_NUM_DEFAULT;
extern const int64_t CONFIG_LOGS_LOG_ROTATE_NUM_MIN;
extern const int64_t CONFIG_LOGS_LOG_ROTATE_NUM_MAX;
class Config {
private:
@ -334,7 +336,7 @@ class Config {
Status
CheckLogsMaxLogFileSize(const std::string& value);
Status
CheckLogsDeleteExceeds(const std::string& value);
CheckLogsLogRotateNum(const std::string& value);
std::string
GetConfigStr(const std::string& parent_key, const std::string& child_key, const std::string& default_value = "");
@ -469,7 +471,7 @@ class Config {
Status
GetLogsMaxLogFileSize(int64_t& value);
Status
GetLogsDeleteExceeds(int64_t& value);
GetLogsLogRotateNum(int64_t& value);
Status
GetServerRestartRequired(bool& required);
@ -595,7 +597,7 @@ class Config {
Status
SetLogsMaxLogFileSize(const std::string& value);
Status
SetLogsDeleteExceeds(const std::string& value);
SetLogsLogRotateNum(const std::string& value);
private:
bool restart_required_ = false;

2
core/src/server/Server.cpp
View File

@ -217,7 +217,7 @@ Server::Start() {
STATUS_CHECK(config.GetLogsFatalEnable(fatal_enable));
STATUS_CHECK(config.GetLogsPath(logs_path));
STATUS_CHECK(config.GetLogsMaxLogFileSize(max_log_file_size));
STATUS_CHECK(config.GetLogsDeleteExceeds(delete_exceeds));
STATUS_CHECK(config.GetLogsLogRotateNum(delete_exceeds));
InitLog(trace_enable, debug_enable, info_enable, warning_enable, error_enable, fatal_enable, logs_path,
max_log_file_size, delete_exceeds);
}

52
core/src/utils/LogUtil.cpp
View File

@ -32,6 +32,7 @@ static int trace_idx = 0;
static int error_idx = 0;
static int fatal_idx = 0;
static int64_t logs_delete_exceeds = 1;
static bool enable_log_delete = false;
} // namespace
// TODO(yzb) : change the easylogging library to get the log level from parameter rather than filename
@ -61,7 +62,7 @@ RolloutHandler(const char* filename, std::size_t size, el::Level level) {
case el::Level::Debug: {
s.append("." + std::to_string(++debug_idx));
ret = rename(m.c_str(), s.c_str());
if (debug_idx - logs_delete_exceeds > 0) {
if (enable_log_delete && debug_idx - logs_delete_exceeds > 0) {
std::string to_delete = m + "." + std::to_string(debug_idx - logs_delete_exceeds);
// std::cout << "remote " << to_delete << std::endl;
boost::filesystem::remove(to_delete);
@ -71,7 +72,7 @@ RolloutHandler(const char* filename, std::size_t size, el::Level level) {
case el::Level::Warning: {
s.append("." + std::to_string(++warning_idx));
ret = rename(m.c_str(), s.c_str());
if (warning_idx - logs_delete_exceeds > 0) {
if (enable_log_delete && warning_idx - logs_delete_exceeds > 0) {
std::string to_delete = m + "." + std::to_string(warning_idx - logs_delete_exceeds);
boost::filesystem::remove(to_delete);
}
@ -80,7 +81,7 @@ RolloutHandler(const char* filename, std::size_t size, el::Level level) {
case el::Level::Trace: {
s.append("." + std::to_string(++trace_idx));
ret = rename(m.c_str(), s.c_str());
if (trace_idx - logs_delete_exceeds > 0) {
if (enable_log_delete && trace_idx - logs_delete_exceeds > 0) {
std::string to_delete = m + "." + std::to_string(trace_idx - logs_delete_exceeds);
boost::filesystem::remove(to_delete);
}
@ -89,7 +90,7 @@ RolloutHandler(const char* filename, std::size_t size, el::Level level) {
case el::Level::Error: {
s.append("." + std::to_string(++error_idx));
ret = rename(m.c_str(), s.c_str());
if (error_idx - logs_delete_exceeds > 0) {
if (enable_log_delete && error_idx - logs_delete_exceeds > 0) {
std::string to_delete = m + "." + std::to_string(error_idx - logs_delete_exceeds);
boost::filesystem::remove(to_delete);
}
@ -98,7 +99,7 @@ RolloutHandler(const char* filename, std::size_t size, el::Level level) {
case el::Level::Fatal: {
s.append("." + std::to_string(++fatal_idx));
ret = rename(m.c_str(), s.c_str());
if (fatal_idx - logs_delete_exceeds > 0) {
if (enable_log_delete && fatal_idx - logs_delete_exceeds > 0) {
std::string to_delete = m + "." + std::to_string(fatal_idx - logs_delete_exceeds);
boost::filesystem::remove(to_delete);
}
@ -107,7 +108,7 @@ RolloutHandler(const char* filename, std::size_t size, el::Level level) {
default: {
s.append("." + std::to_string(++global_idx));
ret = rename(m.c_str(), s.c_str());
if (global_idx - logs_delete_exceeds > 0) {
if (enable_log_delete && global_idx - logs_delete_exceeds > 0) {
std::string to_delete = m + "." + std::to_string(global_idx - logs_delete_exceeds);
boost::filesystem::remove(to_delete);
}
@ -183,26 +184,29 @@ InitLog(bool trace_enable, bool debug_enable, bool info_enable, bool warning_ena
defaultConf.set(el::Level::Fatal, el::ConfigurationType::Enabled, "false");
}
// set max_log_file_size = 0 means disable log file rotating
if (max_log_file_size != 0) {
if (max_log_file_size < 64 || max_log_file_size > 512) {
return Status(SERVER_UNEXPECTED_ERROR,
"max_log_file_size must in range[64, 512], now is " + std::to_string(max_log_file_size));
}
max_log_file_size *= 1024 * 1024;
defaultConf.setGlobally(el::ConfigurationType::MaxLogFileSize, std::to_string(max_log_file_size));
el::Loggers::addFlag(el::LoggingFlag::StrictLogFileSizeCheck);
el::Helpers::installPreRollOutCallback(RolloutHandler);
el::Loggers::addFlag(el::LoggingFlag::DisableApplicationAbortOnFatalLog);
if (max_log_file_size < CONFIG_LOGS_MAX_LOG_FILE_SIZE_MIN ||
max_log_file_size > CONFIG_LOGS_MAX_LOG_FILE_SIZE_MAX) {
return Status(SERVER_UNEXPECTED_ERROR, "max_log_file_size must in range[" +
std::to_string(CONFIG_LOGS_MAX_LOG_FILE_SIZE_MIN) + ", " +
std::to_string(CONFIG_LOGS_MAX_LOG_FILE_SIZE_MAX) + "], now is " +
std::to_string(max_log_file_size));
}
max_log_file_size *= 1024 * 1024;
defaultConf.setGlobally(el::ConfigurationType::MaxLogFileSize, std::to_string(max_log_file_size));
el::Loggers::addFlag(el::LoggingFlag::StrictLogFileSizeCheck);
el::Helpers::installPreRollOutCallback(RolloutHandler);
el::Loggers::addFlag(el::LoggingFlag::DisableApplicationAbortOnFatalLog);
// set delete_exceeds = 0 means disable throw away log file even they reach certain limit.
if (delete_exceeds != 0) {
if (delete_exceeds < 1 || delete_exceeds > 4096) {
return Status(SERVER_UNEXPECTED_ERROR,
"delete_exceeds must in range[1, 4096], now is " + std::to_string(delete_exceeds));
}
logs_delete_exceeds = delete_exceeds;
// set delete_exceeds = 0 means disable throw away log file even they reach certain limit.
if (delete_exceeds != 0) {
if (delete_exceeds < CONFIG_LOGS_LOG_ROTATE_NUM_MIN || delete_exceeds > CONFIG_LOGS_LOG_ROTATE_NUM_MAX) {
return Status(SERVER_UNEXPECTED_ERROR, "delete_exceeds must in range[" +
std::to_string(CONFIG_LOGS_LOG_ROTATE_NUM_MIN) + ", " +
std::to_string(CONFIG_LOGS_LOG_ROTATE_NUM_MAX) + "], now is " +
std::to_string(delete_exceeds));
}
enable_log_delete = true;
logs_delete_exceeds = delete_exceeds;
}
el::Loggers::reconfigureLogger("default", defaultConf);

519
core/unittest/server/test_config.cpp
View File

@ -134,7 +134,6 @@ TEST_F(ConfigTest, CONFIG_TEST) {
}
TEST_F(ConfigTest, SERVER_CONFIG_VALID_TEST) {
std::string config_path(CONFIG_PATH);
milvus::server::Config& config = milvus::server::Config::GetInstance();
std::string str_val;
int64_t int64_val;
@ -359,6 +358,52 @@ TEST_F(ConfigTest, SERVER_CONFIG_VALID_TEST) {
ASSERT_TRUE(config.SetWalConfigWalPath(wal_path).ok());
ASSERT_TRUE(config.GetWalConfigWalPath(str_val).ok());
ASSERT_TRUE(str_val == wal_path);
/* logs config */
bool logs_trace_enable = false;
ASSERT_TRUE(config.SetLogsTraceEnable(std::to_string(logs_trace_enable)).ok());
ASSERT_TRUE(config.GetLogsTraceEnable(bool_val).ok());
ASSERT_TRUE(bool_val == logs_trace_enable);
bool logs_debug_enable = false;
ASSERT_TRUE(config.SetLogsDebugEnable(std::to_string(logs_debug_enable)).ok());
ASSERT_TRUE(config.GetLogsDebugEnable(bool_val).ok());
ASSERT_TRUE(bool_val == logs_debug_enable);
bool logs_info_enable = false;
ASSERT_TRUE(config.SetLogsTraceEnable(std::to_string(logs_info_enable)).ok());
ASSERT_TRUE(config.GetLogsTraceEnable(bool_val).ok());
ASSERT_TRUE(bool_val == logs_info_enable);
bool logs_warning_enable = false;
ASSERT_TRUE(config.SetLogsDebugEnable(std::to_string(logs_warning_enable)).ok());
ASSERT_TRUE(config.GetLogsDebugEnable(bool_val).ok());
ASSERT_TRUE(bool_val == logs_warning_enable);
bool logs_error_enable = false;
ASSERT_TRUE(config.SetLogsTraceEnable(std::to_string(logs_error_enable)).ok());
ASSERT_TRUE(config.GetLogsTraceEnable(bool_val).ok());
ASSERT_TRUE(bool_val == logs_error_enable);
bool logs_fatal_enable = false;
ASSERT_TRUE(config.SetLogsDebugEnable(std::to_string(logs_fatal_enable)).ok());
ASSERT_TRUE(config.GetLogsDebugEnable(bool_val).ok());
ASSERT_TRUE(bool_val == logs_fatal_enable);
std::string logs_path = "/tmp/aaa/logs";
ASSERT_TRUE(config.SetLogsPath(logs_path).ok());
ASSERT_TRUE(config.GetLogsPath(str_val).ok());
ASSERT_TRUE(str_val == logs_path);
int64_t logs_max_log_file_size = 1000;
ASSERT_TRUE(config.SetLogsMaxLogFileSize(std::to_string(logs_max_log_file_size)).ok());
ASSERT_TRUE(config.GetLogsMaxLogFileSize(int64_val).ok());
ASSERT_TRUE(int64_val == logs_max_log_file_size);
int64_t logs_log_rotate_num = 100;
ASSERT_TRUE(config.SetLogsLogRotateNum(std::to_string(logs_log_rotate_num)).ok());
ASSERT_TRUE(config.GetLogsLogRotateNum(int64_val).ok());
ASSERT_TRUE(int64_val == logs_log_rotate_num);
}
std::string
@ -374,181 +419,198 @@ gen_set_command(const std::string& parent_node, const std::string& child_node, c
}
TEST_F(ConfigTest, SERVER_CONFIG_CLI_TEST) {
// std::string config_path(CONFIG_PATH);
// milvus::Status s;
//
// std::string conf_file = std::string(CONFIG_PATH) + VALID_CONFIG_FILE;
// milvus::server::Config& config = milvus::server::Config::GetInstance();
//
// auto status = config.LoadConfigFile(conf_file);
// ASSERT_TRUE(status.ok()) << status.message();
//
// std::string get_cmd, set_cmd;
// std::string result, dummy;
//
// s = config.ProcessConfigCli(result, "get_config *");
// ASSERT_TRUE(s.ok());
//
// /* server config */
// std::string server_addr = "192.168.1.155";
// get_cmd = gen_get_command(ms::CONFIG_SERVER, ms::CONFIG_SERVER_ADDRESS);
// set_cmd = gen_set_command(ms::CONFIG_SERVER, ms::CONFIG_SERVER_ADDRESS, server_addr);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
//
// /* db config */
// std::string db_backend_url = "sqlite://milvus:zilliz@:/";
// get_cmd = gen_get_command(ms::CONFIG_DB, ms::CONFIG_DB_BACKEND_URL);
// set_cmd = gen_set_command(ms::CONFIG_DB, ms::CONFIG_DB_BACKEND_URL, db_backend_url);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
//
// /* metric config */
// std::string metric_enable_monitor = "false";
// get_cmd = gen_get_command(ms::CONFIG_METRIC, ms::CONFIG_METRIC_ENABLE_MONITOR);
// set_cmd = gen_set_command(ms::CONFIG_METRIC, ms::CONFIG_METRIC_ENABLE_MONITOR, metric_enable_monitor);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
//
// /* storage config */
// std::string storage_primary_path = "/tmp/milvus1";
// get_cmd = gen_get_command(ms::CONFIG_STORAGE, ms::CONFIG_STORAGE_PRIMARY_PATH);
// set_cmd = gen_set_command(ms::CONFIG_STORAGE, ms::CONFIG_STORAGE_PRIMARY_PATH, storage_primary_path);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
//
// /* cache config */
// std::string cache_cpu_cache_capacity = "1";
// get_cmd = gen_get_command(ms::CONFIG_CACHE, ms::CONFIG_CACHE_CPU_CACHE_CAPACITY);
// set_cmd = gen_set_command(ms::CONFIG_CACHE, ms::CONFIG_CACHE_CPU_CACHE_CAPACITY, cache_cpu_cache_capacity);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
// ASSERT_TRUE(result == cache_cpu_cache_capacity);
//
// std::string cache_cpu_cache_threshold = "0.1";
// get_cmd = gen_get_command(ms::CONFIG_CACHE, ms::CONFIG_CACHE_CPU_CACHE_THRESHOLD);
// set_cmd = gen_set_command(ms::CONFIG_CACHE, ms::CONFIG_CACHE_CPU_CACHE_THRESHOLD, cache_cpu_cache_threshold);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
// ASSERT_TRUE(result == cache_cpu_cache_threshold);
//
// std::string cache_insert_buffer_size = "1";
// get_cmd = gen_get_command(ms::CONFIG_CACHE, ms::CONFIG_CACHE_INSERT_BUFFER_SIZE);
// set_cmd = gen_set_command(ms::CONFIG_CACHE, ms::CONFIG_CACHE_INSERT_BUFFER_SIZE, cache_insert_buffer_size);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
// ASSERT_TRUE(result == cache_insert_buffer_size);
//
// std::string cache_insert_data = "true";
// get_cmd = gen_get_command(ms::CONFIG_CACHE, ms::CONFIG_CACHE_CACHE_INSERT_DATA);
// set_cmd = gen_set_command(ms::CONFIG_CACHE, ms::CONFIG_CACHE_CACHE_INSERT_DATA, cache_insert_data);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
// ASSERT_TRUE(result == cache_insert_data);
//
// /* engine config */
// std::string engine_use_blas_threshold = "50";
// get_cmd = gen_get_command(ms::CONFIG_ENGINE, ms::CONFIG_ENGINE_USE_BLAS_THRESHOLD);
// set_cmd = gen_set_command(ms::CONFIG_ENGINE, ms::CONFIG_ENGINE_USE_BLAS_THRESHOLD, engine_use_blas_threshold);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
// ASSERT_TRUE(result == engine_use_blas_threshold);
//
// std::string engine_omp_thread_num = "1";
// get_cmd = gen_get_command(ms::CONFIG_ENGINE, ms::CONFIG_ENGINE_OMP_THREAD_NUM);
// set_cmd = gen_set_command(ms::CONFIG_ENGINE, ms::CONFIG_ENGINE_OMP_THREAD_NUM, engine_omp_thread_num);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
// ASSERT_TRUE(result == engine_omp_thread_num);
//
// std::string engine_simd_type = "sse";
// get_cmd = gen_get_command(ms::CONFIG_ENGINE, ms::CONFIG_ENGINE_SIMD_TYPE);
// set_cmd = gen_set_command(ms::CONFIG_ENGINE, ms::CONFIG_ENGINE_SIMD_TYPE, engine_simd_type);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
// ASSERT_TRUE(result == engine_simd_type);
//
//#ifdef MILVUS_GPU_VERSION
// std::string engine_gpu_search_threshold = "800";
// get_cmd = gen_get_command(ms::CONFIG_ENGINE, ms::CONFIG_ENGINE_GPU_SEARCH_THRESHOLD);
// set_cmd = gen_set_command(ms::CONFIG_ENGINE, ms::CONFIG_ENGINE_GPU_SEARCH_THRESHOLD, engine_gpu_search_threshold);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
// ASSERT_TRUE(result == engine_gpu_search_threshold);
//#endif
//
// /* gpu resource config */
//#ifdef MILVUS_GPU_VERSION
// std::string resource_enable_gpu = "true";
// get_cmd = gen_get_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_ENABLE);
// set_cmd = gen_set_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_ENABLE, resource_enable_gpu);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
// ASSERT_TRUE(result == resource_enable_gpu);
//
// std::string gpu_cache_capacity = "1";
// get_cmd = gen_get_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_CACHE_CAPACITY);
// set_cmd = gen_set_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_CACHE_CAPACITY, gpu_cache_capacity);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
// ASSERT_TRUE(result == gpu_cache_capacity);
//
// std::string gpu_cache_threshold = "0.2";
// get_cmd = gen_get_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_CACHE_THRESHOLD);
// set_cmd = gen_set_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_CACHE_THRESHOLD, gpu_cache_threshold);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
// ASSERT_TRUE(result == gpu_cache_threshold);
//
// std::string search_resources = "gpu0";
// get_cmd = gen_get_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_SEARCH_RESOURCES);
// set_cmd = gen_set_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_SEARCH_RESOURCES, search_resources);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
// ASSERT_TRUE(result == search_resources);
//
// std::string build_index_resources = "gpu0";
// get_cmd = gen_get_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_BUILD_INDEX_RESOURCES);
// set_cmd =
// gen_set_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_BUILD_INDEX_RESOURCES, build_index_resources);
// s = config.ProcessConfigCli(dummy, set_cmd);
// ASSERT_TRUE(s.ok());
// s = config.ProcessConfigCli(result, get_cmd);
// ASSERT_TRUE(s.ok());
// ASSERT_TRUE(result == build_index_resources);
//#endif
std::string conf_file = std::string(CONFIG_PATH) + VALID_CONFIG_FILE;
milvus::server::Config& config = milvus::server::Config::GetInstance();
auto s = config.LoadConfigFile(conf_file);
ASSERT_TRUE(s.ok()) << s.message();
s = config.ResetDefaultConfig();
ASSERT_TRUE(s.ok());
std::string get_cmd, set_cmd;
std::string result, dummy;
s = config.ProcessConfigCli(result, "get_config *");
ASSERT_TRUE(s.ok());
/* server config */
std::string server_addr = "192.168.1.155";
get_cmd = gen_get_command(ms::CONFIG_SERVER, ms::CONFIG_SERVER_ADDRESS);
set_cmd = gen_set_command(ms::CONFIG_SERVER, ms::CONFIG_SERVER_ADDRESS, server_addr);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
/* db config */
std::string db_backend_url = "sqlite://milvus:zilliz@:/";
get_cmd = gen_get_command(ms::CONFIG_DB, ms::CONFIG_DB_BACKEND_URL);
set_cmd = gen_set_command(ms::CONFIG_DB, ms::CONFIG_DB_BACKEND_URL, db_backend_url);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
/* metric config */
std::string metric_enable_monitor = "false";
get_cmd = gen_get_command(ms::CONFIG_METRIC, ms::CONFIG_METRIC_ENABLE_MONITOR);
set_cmd = gen_set_command(ms::CONFIG_METRIC, ms::CONFIG_METRIC_ENABLE_MONITOR, metric_enable_monitor);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
/* storage config */
std::string storage_primary_path = "/tmp/milvus1";
get_cmd = gen_get_command(ms::CONFIG_STORAGE, ms::CONFIG_STORAGE_PRIMARY_PATH);
set_cmd = gen_set_command(ms::CONFIG_STORAGE, ms::CONFIG_STORAGE_PRIMARY_PATH, storage_primary_path);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
/* cache config */
std::string cache_cpu_cache_capacity = "1";
get_cmd = gen_get_command(ms::CONFIG_CACHE, ms::CONFIG_CACHE_CPU_CACHE_CAPACITY);
set_cmd = gen_set_command(ms::CONFIG_CACHE, ms::CONFIG_CACHE_CPU_CACHE_CAPACITY, cache_cpu_cache_capacity);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
ASSERT_TRUE(result == cache_cpu_cache_capacity);
std::string cache_cpu_cache_threshold = "0.1";
get_cmd = gen_get_command(ms::CONFIG_CACHE, ms::CONFIG_CACHE_CPU_CACHE_THRESHOLD);
set_cmd = gen_set_command(ms::CONFIG_CACHE, ms::CONFIG_CACHE_CPU_CACHE_THRESHOLD, cache_cpu_cache_threshold);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
ASSERT_TRUE(result == cache_cpu_cache_threshold);
std::string cache_insert_buffer_size = "1";
get_cmd = gen_get_command(ms::CONFIG_CACHE, ms::CONFIG_CACHE_INSERT_BUFFER_SIZE);
set_cmd = gen_set_command(ms::CONFIG_CACHE, ms::CONFIG_CACHE_INSERT_BUFFER_SIZE, cache_insert_buffer_size);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
ASSERT_TRUE(result == cache_insert_buffer_size);
std::string cache_insert_data = "true";
get_cmd = gen_get_command(ms::CONFIG_CACHE, ms::CONFIG_CACHE_CACHE_INSERT_DATA);
set_cmd = gen_set_command(ms::CONFIG_CACHE, ms::CONFIG_CACHE_CACHE_INSERT_DATA, cache_insert_data);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
ASSERT_TRUE(result == cache_insert_data);
/* engine config */
std::string engine_use_blas_threshold = "50";
get_cmd = gen_get_command(ms::CONFIG_ENGINE, ms::CONFIG_ENGINE_USE_BLAS_THRESHOLD);
set_cmd = gen_set_command(ms::CONFIG_ENGINE, ms::CONFIG_ENGINE_USE_BLAS_THRESHOLD, engine_use_blas_threshold);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
ASSERT_TRUE(result == engine_use_blas_threshold);
std::string engine_omp_thread_num = "1";
get_cmd = gen_get_command(ms::CONFIG_ENGINE, ms::CONFIG_ENGINE_OMP_THREAD_NUM);
set_cmd = gen_set_command(ms::CONFIG_ENGINE, ms::CONFIG_ENGINE_OMP_THREAD_NUM, engine_omp_thread_num);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
ASSERT_TRUE(result == engine_omp_thread_num);
std::string engine_simd_type = "sse";
get_cmd = gen_get_command(ms::CONFIG_ENGINE, ms::CONFIG_ENGINE_SIMD_TYPE);
set_cmd = gen_set_command(ms::CONFIG_ENGINE, ms::CONFIG_ENGINE_SIMD_TYPE, engine_simd_type);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
ASSERT_TRUE(result == engine_simd_type);
#ifdef MILVUS_GPU_VERSION
std::string engine_gpu_search_threshold = "800";
get_cmd = gen_get_command(ms::CONFIG_ENGINE, ms::CONFIG_ENGINE_GPU_SEARCH_THRESHOLD);
set_cmd = gen_set_command(ms::CONFIG_ENGINE, ms::CONFIG_ENGINE_GPU_SEARCH_THRESHOLD, engine_gpu_search_threshold);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
ASSERT_TRUE(result == engine_gpu_search_threshold);
#endif
/* gpu resource config */
#ifdef MILVUS_GPU_VERSION
std::string resource_enable_gpu = "true";
get_cmd = gen_get_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_ENABLE);
set_cmd = gen_set_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_ENABLE, resource_enable_gpu);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
ASSERT_TRUE(result == resource_enable_gpu);
std::string gpu_cache_capacity = "1";
get_cmd = gen_get_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_CACHE_CAPACITY);
set_cmd = gen_set_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_CACHE_CAPACITY, gpu_cache_capacity);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
ASSERT_TRUE(result == gpu_cache_capacity);
std::string gpu_cache_threshold = "0.2";
get_cmd = gen_get_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_CACHE_THRESHOLD);
set_cmd = gen_set_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_CACHE_THRESHOLD, gpu_cache_threshold);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
ASSERT_TRUE(result == gpu_cache_threshold);
std::string search_resources = "gpu0";
get_cmd = gen_get_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_SEARCH_RESOURCES);
set_cmd = gen_set_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_SEARCH_RESOURCES, search_resources);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
ASSERT_TRUE(result == search_resources);
std::string build_index_resources = "gpu0";
get_cmd = gen_get_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_BUILD_INDEX_RESOURCES);
set_cmd =
gen_set_command(ms::CONFIG_GPU_RESOURCE, ms::CONFIG_GPU_RESOURCE_BUILD_INDEX_RESOURCES, build_index_resources);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
ASSERT_TRUE(result == build_index_resources);
#endif
/* wal config */
std::string wal_path = "/tmp/aaa/wal";
get_cmd = gen_get_command(ms::CONFIG_WAL, ms::CONFIG_WAL_WAL_PATH);
set_cmd = gen_set_command(ms::CONFIG_WAL, ms::CONFIG_WAL_WAL_PATH, wal_path);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
/* logs config */
std::string logs_path = "/tmp/aaa/logs";
get_cmd = gen_get_command(ms::CONFIG_LOGS, ms::CONFIG_LOGS_PATH);
set_cmd = gen_set_command(ms::CONFIG_LOGS, ms::CONFIG_LOGS_PATH, logs_path);
s = config.ProcessConfigCli(dummy, set_cmd);
ASSERT_TRUE(s.ok());
s = config.ProcessConfigCli(result, get_cmd);
ASSERT_TRUE(s.ok());
}
TEST_F(ConfigTest, SERVER_CONFIG_INVALID_TEST) {
@ -674,6 +736,19 @@ TEST_F(ConfigTest, SERVER_CONFIG_INVALID_TEST) {
ASSERT_FALSE(config.SetWalConfigWalPath("").ok());
ASSERT_FALSE(config.SetWalConfigBufferSize("-1").ok());
ASSERT_FALSE(config.SetWalConfigBufferSize("a").ok());
/* wal config */
ASSERT_FALSE(config.SetLogsTraceEnable("invalid").ok());
ASSERT_FALSE(config.SetLogsDebugEnable("invalid").ok());
ASSERT_FALSE(config.SetLogsInfoEnable("invalid").ok());
ASSERT_FALSE(config.SetLogsWarningEnable("invalid").ok());
ASSERT_FALSE(config.SetLogsErrorEnable("invalid").ok());
ASSERT_FALSE(config.SetLogsFatalEnable("invalid").ok());
ASSERT_FALSE(config.SetLogsPath("").ok());
ASSERT_FALSE(config.SetLogsMaxLogFileSize("-1").ok());
ASSERT_FALSE(config.SetLogsMaxLogFileSize("511").ok());
ASSERT_FALSE(config.SetLogsLogRotateNum("-1").ok());
ASSERT_FALSE(config.SetLogsLogRotateNum("1025").ok());
}
TEST_F(ConfigTest, SERVER_CONFIG_TEST) {
@ -919,6 +994,52 @@ TEST_F(ConfigTest, SERVER_CONFIG_VALID_FAIL_TEST) {
s = config.ValidateConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_wal_path_fail");
/* logs config */
fiu_enable("check_logs_trace_enable_fail", 1, NULL, 0);
s = config.ValidateConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_trace_enable_fail");
fiu_enable("check_logs_debug_enable_fail", 1, NULL, 0);
s = config.ValidateConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_debug_enable_fail");
fiu_enable("check_logs_info_enable_fail", 1, NULL, 0);
s = config.ValidateConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_info_enable_fail");
fiu_enable("check_logs_warning_enable_fail", 1, NULL, 0);
s = config.ValidateConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_warning_enable_fail");
fiu_enable("check_logs_error_enable_fail", 1, NULL, 0);
s = config.ValidateConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_error_enable_fail");
fiu_enable("check_logs_fatal_enable_fail", 1, NULL, 0);
s = config.ValidateConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_fatal_enable_fail");
fiu_enable("check_logs_path_fail", 1, NULL, 0);
s = config.ValidateConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_path_fail");
fiu_enable("check_logs_max_log_file_size_fail", 1, NULL, 0);
s = config.ValidateConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_max_log_file_size_fail");
fiu_enable("check_logs_log_rotate_num_fail", 1, NULL, 0);
s = config.ValidateConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_log_rotate_num_fail");
}
TEST_F(ConfigTest, SERVER_CONFIG_RESET_DEFAULT_CONFIG_FAIL_TEST) {
@ -1088,6 +1209,52 @@ TEST_F(ConfigTest, SERVER_CONFIG_RESET_DEFAULT_CONFIG_FAIL_TEST) {
s = config.ResetDefaultConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_wal_path_fail");
/* logs config */
fiu_enable("check_logs_trace_enable_fail", 1, NULL, 0);
s = config.ResetDefaultConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_trace_enable_fail");
fiu_enable("check_logs_debug_enable_fail", 1, NULL, 0);
s = config.ResetDefaultConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_debug_enable_fail");
fiu_enable("check_logs_info_enable_fail", 1, NULL, 0);
s = config.ResetDefaultConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_info_enable_fail");
fiu_enable("check_logs_warning_enable_fail", 1, NULL, 0);
s = config.ResetDefaultConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_warning_enable_fail");
fiu_enable("check_logs_error_enable_fail", 1, NULL, 0);
s = config.ResetDefaultConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_error_enable_fail");
fiu_enable("check_logs_fatal_enable_fail", 1, NULL, 0);
s = config.ResetDefaultConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_fatal_enable_fail");
fiu_enable("check_logs_path_fail", 1, NULL, 0);
s = config.ResetDefaultConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_path_fail");
fiu_enable("check_logs_max_log_file_size_fail", 1, NULL, 0);
s = config.ResetDefaultConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_max_log_file_size_fail");
fiu_enable("check_logs_log_rotate_num_fail", 1, NULL, 0);
s = config.ResetDefaultConfig();
ASSERT_FALSE(s.ok());
fiu_disable("check_logs_log_rotate_num_fail");
}
TEST_F(ConfigTest, SERVER_CONFIG_OTHER_CONFIGS_FAIL_TEST) {

2
core/unittest/server/test_util.cpp
View File

@ -246,7 +246,7 @@ TEST(UtilTest, BLOCKINGQUEUE_TEST) {
}
TEST(UtilTest, LOG_TEST) {
auto status = milvus::server::InitLog(true, true, true, true, true, true, "/tmp/test_util", 256, 10);
auto status = milvus::server::InitLog(true, true, true, true, true, true, "/tmp/test_util", 1024, 10);
ASSERT_TRUE(status.ok());
EXPECT_FALSE(el::Loggers::hasFlag(el::LoggingFlag::NewLineForContainer));