/** * Copyright (c) 2021 OceanBase * OceanBase CE is licensed under Mulan PubL v2. * You can use this software according to the terms and conditions of the Mulan PubL v2. * You may obtain a copy of Mulan PubL v2 at: * http://license.coscl.org.cn/MulanPubL-2.0 * 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 PubL v2 for more details. */ #include #include "lib/file/file_directory_utils.h" #include "share/object_storage/ob_device_config_mgr.h" #include "share/object_storage/ob_device_config_parser.h" #define private public #undef private namespace oceanbase { namespace unittest { using namespace oceanbase::common; using namespace oceanbase::share; class TestDeviceConfig: public ::testing::Test { public: TestDeviceConfig() {} virtual ~TestDeviceConfig() {} virtual void SetUp() {} virtual void TearDown() {} static void SetUpTestCase() {} static void TearDownTestCase() {} private: DISALLOW_COPY_AND_ASSIGN(TestDeviceConfig); }; TEST_F(TestDeviceConfig, parser_and_dump_load_and_get) { // 1. test device config parser ObDeviceConfig config; const char *used_for_str = "used_for=LOG"; const char *path_str = "path=oss://bucket-name/root_dir"; const char *endpoint_str = "endpoint=host=cn-xxx.com"; const char *access_info_str = "access_info=access_id=aaa&encrypt_key=bbb"; const char *extension_str = "extension=appid=123&checksum_type=crc32"; const char *state_str = "state=ADDED"; const char *state_info_str = "state_info=is_connective=true"; const char *create_timestamp_str = "create_timestamp=1679579590156"; const char *last_check_timestamp_str = "last_check_timestamp=1679579590256"; const char *op_id_str = "op_id=1"; const char *sub_op_id_str = "sub_op_id=2"; const char *storage_id_str = "storage_id=1"; const char *max_iops_str = "max_iops=10000"; const char *max_bandwidth_str = "max_bandwidth=1024000000"; ASSERT_EQ(OB_SUCCESS, ObDeviceConfigParser::parse_device_config_field(used_for_str, config)); ASSERT_EQ(OB_SUCCESS, ObDeviceConfigParser::parse_device_config_field(path_str, config)); ASSERT_EQ(OB_SUCCESS, ObDeviceConfigParser::parse_device_config_field(endpoint_str, config)); ASSERT_EQ(OB_SUCCESS, ObDeviceConfigParser::parse_device_config_field(access_info_str, config)); ASSERT_EQ(OB_SUCCESS, ObDeviceConfigParser::parse_device_config_field(extension_str, config)); ASSERT_EQ(OB_SUCCESS, ObDeviceConfigParser::parse_device_config_field(state_str, config)); ASSERT_EQ(OB_SUCCESS, ObDeviceConfigParser::parse_device_config_field(state_info_str, config)); ASSERT_EQ(OB_SUCCESS, ObDeviceConfigParser::parse_device_config_field(create_timestamp_str, config)); ASSERT_EQ(OB_SUCCESS, ObDeviceConfigParser::parse_device_config_field(last_check_timestamp_str, config)); ASSERT_EQ(OB_SUCCESS, ObDeviceConfigParser::parse_device_config_field(op_id_str, config)); ASSERT_EQ(OB_SUCCESS, ObDeviceConfigParser::parse_device_config_field(sub_op_id_str, config)); ASSERT_EQ(OB_SUCCESS, ObDeviceConfigParser::parse_device_config_field(storage_id_str, config)); ASSERT_EQ(OB_SUCCESS, ObDeviceConfigParser::parse_device_config_field(max_iops_str, config)); ASSERT_EQ(OB_SUCCESS, ObDeviceConfigParser::parse_device_config_field(max_bandwidth_str, config)); ASSERT_EQ(0, STRCMP(config.used_for_, "LOG")); ASSERT_EQ(0, STRCMP(config.path_, "oss://bucket-name/root_dir")); ASSERT_EQ(0, STRCMP(config.endpoint_, "host=cn-xxx.com")); ASSERT_EQ(0, STRCMP(config.access_info_, "access_id=aaa&encrypt_key=bbb")); ASSERT_EQ(0, STRCMP(config.extension_, "appid=123&checksum_type=crc32")); ASSERT_EQ(0, STRCMP(config.state_, "ADDED")); ASSERT_EQ(0, STRCMP(config.state_info_, "is_connective=true")); ASSERT_EQ(1679579590156, config.create_timestamp_); ASSERT_EQ(1679579590256, config.last_check_timestamp_); ASSERT_EQ(1, config.op_id_); ASSERT_EQ(2, config.sub_op_id_); ASSERT_EQ(1, config.storage_id_); ASSERT_EQ(10000, config.max_iops_); ASSERT_EQ(1024000000, config.max_bandwidth_); // 2. test device manifest dump2file and load ObDeviceManifest device_manifest; ObArray dump_configs; ObArray load_configs; ASSERT_EQ(OB_SUCCESS, dump_configs.push_back(config)); ObDeviceConfig config2 = config; MEMSET(config2.used_for_, 0, sizeof(config2.used_for_)); STRCPY(config2.used_for_, "DATA"); MEMSET(config2.old_access_info_, 0, sizeof(config2.old_access_info_)); STRCPY(config2.old_access_info_, "access_id=aaa&encrypt_key=bbb"); MEMSET(config2.access_info_, 0, sizeof(config2.access_info_)); STRCPY(config2.access_info_, "access_id=ccccc&encrypt_key=ddddd"); MEMSET(config2.old_extension_, 0, sizeof(config2.old_extension_)); STRCPY(config2.old_extension_, "appid=123&checksum_type=crc32"); MEMSET(config2.extension_, 0, sizeof(config2.extension_)); STRCPY(config2.extension_, "appid=456&checksum_type=md5"); config2.op_id_ = 3; config2.sub_op_id_ = 4; config2.storage_id_ = 2; ASSERT_EQ(OB_SUCCESS, dump_configs.push_back(config2)); ObDeviceManifest::HeadSection dump_head; dump_head.device_num_ = 2; dump_head.modify_timestamp_us_ = ObTimeUtil::fast_current_time(); dump_head.last_op_id_ = 3; dump_head.last_sub_op_id_ = 4; ObDeviceManifest::HeadSection load_head; const char *data_dir = "./TestDeviceConfigDir"; ASSERT_EQ(OB_SUCCESS, FileDirectoryUtils::create_directory(data_dir)); ASSERT_EQ(OB_SUCCESS, device_manifest.init(data_dir)); ASSERT_EQ(OB_SUCCESS, device_manifest.dump2file(dump_configs, dump_head)); ASSERT_EQ(OB_SUCCESS, device_manifest.load(load_configs, load_head)); // sort by used_for, path and endpoint ObArray sorted_dump_configs; ASSERT_EQ(OB_SUCCESS, sorted_dump_configs.push_back(dump_configs[1])); ASSERT_EQ(OB_SUCCESS, sorted_dump_configs.push_back(dump_configs[0])); ASSERT_EQ(2, load_configs.count()); for (int64_t i = 0; i < load_configs.count(); ++i) { ASSERT_EQ(0, STRCMP(sorted_dump_configs[i].used_for_, load_configs[i].used_for_)); ASSERT_EQ(0, STRCMP(sorted_dump_configs[i].path_, load_configs[i].path_)); ASSERT_EQ(0, STRCMP(sorted_dump_configs[i].endpoint_, load_configs[i].endpoint_)); ASSERT_EQ(0, STRCMP(sorted_dump_configs[i].access_info_, load_configs[i].access_info_)); ASSERT_EQ(0, STRCMP(sorted_dump_configs[i].encrypt_info_, load_configs[i].encrypt_info_)); ASSERT_EQ(0, STRCMP(sorted_dump_configs[i].extension_, load_configs[i].extension_)); ASSERT_EQ(0, STRCMP(sorted_dump_configs[i].old_access_info_, load_configs[i].old_access_info_)); ASSERT_EQ(0, STRCMP(sorted_dump_configs[i].old_encrypt_info_, load_configs[i].old_encrypt_info_)); ASSERT_EQ(0, STRCMP(sorted_dump_configs[i].old_extension_, load_configs[i].old_extension_)); ASSERT_EQ(0, STRCMP(sorted_dump_configs[i].state_, load_configs[i].state_)); ASSERT_EQ(0, STRCMP(sorted_dump_configs[i].state_info_, load_configs[i].state_info_)); ASSERT_EQ(sorted_dump_configs[i].create_timestamp_, load_configs[i].create_timestamp_); ASSERT_EQ(sorted_dump_configs[i].last_check_timestamp_, load_configs[i].last_check_timestamp_); ASSERT_EQ(sorted_dump_configs[i].op_id_, load_configs[i].op_id_); ASSERT_EQ(sorted_dump_configs[i].sub_op_id_, load_configs[i].sub_op_id_); ASSERT_EQ(sorted_dump_configs[i].storage_id_, load_configs[i].storage_id_); ASSERT_EQ(sorted_dump_configs[i].max_iops_, load_configs[i].max_iops_); ASSERT_EQ(sorted_dump_configs[i].max_bandwidth_, load_configs[i].max_bandwidth_); } ASSERT_EQ(dump_head.version_, load_head.version_); ASSERT_EQ(dump_head.head_checksum_, load_head.head_checksum_); ASSERT_EQ(dump_head.device_checksum_, load_head.device_checksum_); ASSERT_EQ(dump_head.device_num_, load_head.device_num_); ASSERT_EQ(dump_head.modify_timestamp_us_, load_head.modify_timestamp_us_); ASSERT_EQ(dump_head.last_op_id_, load_head.last_op_id_); ASSERT_EQ(dump_head.last_sub_op_id_, load_head.last_sub_op_id_); // 3. test device config mgr ObDeviceConfigMgr &config_mgr = ObDeviceConfigMgr::get_instance(); ASSERT_EQ(OB_SUCCESS, config_mgr.init(data_dir)); ASSERT_EQ(OB_SUCCESS, config_mgr.load_configs()); // test get_all_device_configs ObArray all_configs; ASSERT_EQ(OB_SUCCESS, config_mgr.get_all_device_configs(all_configs)); ASSERT_EQ(2, all_configs.count()); // test get_device_config ObDeviceConfig data_device_config; ASSERT_EQ(OB_SUCCESS, config_mgr.get_device_config(ObStorageUsedType::TYPE::USED_TYPE_DATA, data_device_config)); ASSERT_EQ(0, STRCMP(config2.used_for_, data_device_config.used_for_)); ASSERT_EQ(0, STRCMP(config2.path_, data_device_config.path_)); ASSERT_EQ(0, STRCMP(config2.endpoint_, data_device_config.endpoint_)); ASSERT_EQ(0, STRCMP(config2.access_info_, data_device_config.access_info_)); ASSERT_EQ(0, STRCMP(config2.encrypt_info_, data_device_config.encrypt_info_)); ASSERT_EQ(0, STRCMP(config2.extension_, data_device_config.extension_)); ASSERT_EQ(0, STRCMP(config2.old_access_info_, data_device_config.old_access_info_)); ASSERT_EQ(0, STRCMP(config2.old_encrypt_info_, data_device_config.old_encrypt_info_)); ASSERT_EQ(0, STRCMP(config2.old_extension_, data_device_config.old_extension_)); ASSERT_EQ(0, STRCMP(config2.state_, data_device_config.state_)); ASSERT_EQ(0, STRCMP(config2.state_info_, data_device_config.state_info_)); ASSERT_EQ(config2.create_timestamp_, data_device_config.create_timestamp_); ASSERT_EQ(config2.last_check_timestamp_, data_device_config.last_check_timestamp_); ASSERT_EQ(config2.op_id_, data_device_config.op_id_); ASSERT_EQ(config2.sub_op_id_, data_device_config.sub_op_id_); ASSERT_EQ(config2.storage_id_, data_device_config.storage_id_); ASSERT_EQ(config2.max_iops_, data_device_config.max_iops_); ASSERT_EQ(config2.max_bandwidth_, data_device_config.max_bandwidth_); ObDeviceConfig log_device_config; ASSERT_EQ(OB_SUCCESS, config_mgr.get_device_config(ObStorageUsedType::TYPE::USED_TYPE_LOG, log_device_config)); ASSERT_EQ(0, STRCMP(config.used_for_, log_device_config.used_for_)); ASSERT_EQ(0, STRCMP(config.path_, log_device_config.path_)); ASSERT_EQ(0, STRCMP(config.endpoint_, log_device_config.endpoint_)); ASSERT_EQ(0, STRCMP(config.access_info_, log_device_config.access_info_)); ASSERT_EQ(0, STRCMP(config.encrypt_info_, log_device_config.encrypt_info_)); ASSERT_EQ(0, STRCMP(config.extension_, log_device_config.extension_)); ASSERT_EQ(0, STRCMP(config.old_access_info_, log_device_config.old_access_info_)); ASSERT_EQ(0, STRCMP(config.old_encrypt_info_, log_device_config.old_encrypt_info_)); ASSERT_EQ(0, STRCMP(config.old_extension_, log_device_config.old_extension_)); ASSERT_EQ(0, STRCMP(config.state_, log_device_config.state_)); ASSERT_EQ(0, STRCMP(config.state_info_, log_device_config.state_info_)); ASSERT_EQ(config.create_timestamp_, log_device_config.create_timestamp_); ASSERT_EQ(config.last_check_timestamp_, log_device_config.last_check_timestamp_); ASSERT_EQ(config.op_id_, log_device_config.op_id_); ASSERT_EQ(config.sub_op_id_, log_device_config.sub_op_id_); ASSERT_EQ(config.storage_id_, log_device_config.storage_id_); ASSERT_EQ(config.max_iops_, log_device_config.max_iops_); ASSERT_EQ(config.max_bandwidth_, log_device_config.max_bandwidth_); // test get_last_op_id and get_last_sub_op_id uint64_t last_op_id = UINT64_MAX; uint64_t last_sub_op_id = UINT64_MAX; ASSERT_EQ(OB_SUCCESS, config_mgr.get_last_op_id(last_op_id)); ASSERT_EQ(OB_SUCCESS, config_mgr.get_last_sub_op_id(last_sub_op_id)); ASSERT_EQ(3, last_op_id); ASSERT_EQ(4, last_sub_op_id); // test is_op_done bool is_done_3_4 = false; config_mgr.is_op_done(3, 4, is_done_3_4); ASSERT_TRUE(is_done_3_4); bool is_done_1_2 = false; config_mgr.is_op_done(1, 2, is_done_1_2); ASSERT_TRUE(is_done_1_2); bool is_done_3_5 = false; config_mgr.is_op_done(3, 5, is_done_3_5); ASSERT_FALSE(is_done_3_5); ASSERT_EQ(OB_SUCCESS, FileDirectoryUtils::delete_directory_rec(data_dir)); } } // namespace unittest } // namespace oceanbase int main(int argc, char **argv) { oceanbase::common::FileDirectoryUtils::delete_directory_rec("./TestDeviceConfigDir"); system("rm -f test_device_config.log"); OB_LOGGER.set_file_name("test_device_config.log", true); OB_LOGGER.set_log_level("INFO"); ::testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); }