patch 4.0
This commit is contained in:
wangzelin.wzl
311
unittest/storage/slog/test_storage_logger_manager.cpp
Normal file
311
unittest/storage/slog/test_storage_logger_manager.cpp
Normal file
@ -0,0 +1,311 @@
|
||||
/**
|
||||
* 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 <gtest/gtest.h>
|
||||
#include "lib/list/ob_list.h"
|
||||
#include "lib/file/file_directory_utils.h"
|
||||
#include "lib/file/ob_file.h"
|
||||
#include "lib/ob_define.h"
|
||||
#include "storage/blocksstable/ob_data_file_prepare.h"
|
||||
#include "storage/slog/simple_ob_storage_log.h"
|
||||
#include "storage/slog/ob_storage_log_batch_header.h"
|
||||
#include "lib/container/ob_se_array.h"
|
||||
#include "share/ob_simple_mem_limit_getter.h"
|
||||
|
||||
#define private public
|
||||
#include "share/rc/ob_tenant_base.h"
|
||||
#include "storage/slog/ob_storage_logger_manager.h"
|
||||
#include "storage/slog/ob_storage_logger.h"
|
||||
#undef private
|
||||
|
||||
namespace oceanbase
|
||||
{
|
||||
using namespace common;
|
||||
static ObSimpleMemLimitGetter getter;
|
||||
|
||||
namespace storage
|
||||
{
|
||||
|
||||
class TestStorageLoggerManager : public TestDataFilePrepare
|
||||
{
|
||||
public:
|
||||
TestStorageLoggerManager()
|
||||
: TestDataFilePrepare(&getter, "TestStorageLoggerManager")
|
||||
{
|
||||
}
|
||||
virtual ~TestStorageLoggerManager() {}
|
||||
TestStorageLoggerManager(const TestStorageLoggerManager &) = delete;
|
||||
TestStorageLoggerManager &operator = (const TestStorageLoggerManager &) = delete;
|
||||
|
||||
virtual void SetUp();
|
||||
virtual void TearDown();
|
||||
|
||||
public:
|
||||
static const int64_t MAX_FILE_SIZE = 256 * 1024 * 1024;
|
||||
const int64_t MAX_CONCURRENT_ITEM_CNT = !lib::is_mini_mode() ?
|
||||
MAX(128, sysconf(_SC_NPROCESSORS_ONLN) * 2) : 64;
|
||||
|
||||
public:
|
||||
char dir_[128];
|
||||
ObLogCursor start_cursor_;
|
||||
blocksstable::ObLogFileSpec log_file_spec_;
|
||||
};
|
||||
|
||||
void TestStorageLoggerManager::SetUp()
|
||||
{
|
||||
system("rm -rf ./test_storage_logger_mgr");
|
||||
MEMCPY(dir_, "./test_storage_logger_mgr", sizeof("./test_storage_logger_mgr"));
|
||||
start_cursor_.file_id_ = 1;
|
||||
start_cursor_.log_id_ = 1;
|
||||
start_cursor_.offset_ = 0;
|
||||
log_file_spec_.retry_write_policy_ = "normal";
|
||||
log_file_spec_.log_create_policy_ = "normal";
|
||||
log_file_spec_.log_write_policy_ = "truncate";
|
||||
TestDataFilePrepare::TearDown();
|
||||
TestDataFilePrepare::SetUp();
|
||||
SLOGGERMGR.destroy();
|
||||
FileDirectoryUtils::create_full_path("./test_storage_logger_mgr");
|
||||
}
|
||||
|
||||
void TestStorageLoggerManager::TearDown()
|
||||
{
|
||||
system("rm -rf ./test_storage_logger_mgr");
|
||||
TestDataFilePrepare::TearDown();
|
||||
}
|
||||
|
||||
TEST_F(TestStorageLoggerManager, test_manager_basic)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
|
||||
// test invalid init
|
||||
ret = SLOGGERMGR.init(nullptr, MAX_FILE_SIZE, log_file_spec_);
|
||||
ASSERT_NE(OB_SUCCESS, ret);
|
||||
// test normal init
|
||||
ret = SLOGGERMGR.init(dir_, MAX_FILE_SIZE, log_file_spec_);
|
||||
ASSERT_EQ(OB_SUCCESS, ret);
|
||||
ASSERT_EQ(MAX_CONCURRENT_ITEM_CNT, SLOGGERMGR.log_buffers_.capacity());
|
||||
ASSERT_EQ(MAX_CONCURRENT_ITEM_CNT, SLOGGERMGR.slog_items_.capacity());
|
||||
|
||||
ObStorageLogItem *log_item = nullptr;
|
||||
ObStorageLogItem *log_item_local = nullptr;
|
||||
// test invalid item allocation
|
||||
ret = SLOGGERMGR.alloc_item(ObLogConstants::LOG_ITEM_MAX_LENGTH+100,
|
||||
log_item, 1);
|
||||
ASSERT_NE(OB_SUCCESS, ret);
|
||||
// test normal item allocation (not local)
|
||||
ret = SLOGGERMGR.alloc_item(30 * 1024, log_item, 15);
|
||||
ASSERT_EQ(OB_SUCCESS, ret);
|
||||
ASSERT_TRUE(log_item->is_inited_);
|
||||
ASSERT_FALSE(log_item->is_local_);
|
||||
// test normal item allocation (local)
|
||||
ret = SLOGGERMGR.alloc_item(513 * 1024, log_item_local, 1);
|
||||
ASSERT_EQ(OB_SUCCESS, ret);
|
||||
ASSERT_TRUE(log_item_local->is_inited_);
|
||||
ASSERT_TRUE(log_item_local->is_local_);
|
||||
|
||||
// test invalid item free
|
||||
ret = SLOGGERMGR.free_item(nullptr);
|
||||
ASSERT_NE(OB_SUCCESS, ret);
|
||||
// test normal item free
|
||||
ret = SLOGGERMGR.free_item(log_item);
|
||||
ASSERT_EQ(OB_SUCCESS, ret);
|
||||
ret = SLOGGERMGR.free_item(log_item_local);
|
||||
ASSERT_EQ(OB_SUCCESS, ret);
|
||||
|
||||
SLOGGERMGR.destroy();
|
||||
}
|
||||
|
||||
TEST_F(TestStorageLoggerManager, test_slogger_basic)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObLogCursor cursor;
|
||||
cursor.file_id_ = 3;
|
||||
cursor.log_id_ = 5;
|
||||
cursor.offset_ = 500;
|
||||
|
||||
SLOGGERMGR.init(dir_, MAX_FILE_SIZE, log_file_spec_);
|
||||
|
||||
ObStorageLogger *tmp_slogger = OB_NEW(ObStorageLogger, ObModIds::TEST);
|
||||
ASSERT_EQ(OB_SUCCESS, tmp_slogger->init(SLOGGERMGR, 500));
|
||||
ASSERT_EQ(OB_SUCCESS, tmp_slogger->start());
|
||||
|
||||
ObTenantBase tenant_base(5);
|
||||
tenant_base.set(tmp_slogger);
|
||||
ObTenantEnv::set_tenant(&tenant_base);
|
||||
ASSERT_EQ(OB_SUCCESS, tenant_base.init());
|
||||
|
||||
ObTenantSwitchGuard guard;
|
||||
guard.switch_to(5);
|
||||
ObStorageLogger *slogger = MTL(ObStorageLogger*);
|
||||
slogger->start_log(cursor);
|
||||
|
||||
// test is_logger_ok
|
||||
bool is_ok = false;
|
||||
ret = slogger->is_logger_ok(is_ok);
|
||||
ASSERT_EQ(OB_SUCCESS, ret);
|
||||
ASSERT_TRUE(is_ok);
|
||||
|
||||
// test get_active_cursor
|
||||
ObLogCursor tmp_cursor;
|
||||
ret = slogger->get_active_cursor(tmp_cursor);
|
||||
ASSERT_EQ(OB_SUCCESS, ret);
|
||||
ASSERT_EQ(tmp_cursor.file_id_, cursor.file_id_);
|
||||
ASSERT_EQ(tmp_cursor.log_id_, cursor.log_id_);
|
||||
ASSERT_EQ(tmp_cursor.offset_, cursor.offset_);
|
||||
|
||||
// test get_using_disk_space
|
||||
int64_t space;
|
||||
ret = slogger->get_using_disk_space(space);
|
||||
ASSERT_EQ(OB_SUCCESS, ret);
|
||||
ASSERT_EQ(0, space);
|
||||
|
||||
// test get_start_file_id
|
||||
int64_t start_id = 0;
|
||||
ret = slogger->get_start_file_id(start_id, 5);
|
||||
ASSERT_EQ(OB_SUCCESS, ret);
|
||||
ASSERT_EQ(cursor.file_id_, start_id);
|
||||
|
||||
// test normal file remove
|
||||
ret = slogger->remove_useless_log_file(cursor.file_id_+1, OB_SERVER_TENANT_ID);
|
||||
ASSERT_EQ(OB_SUCCESS, ret);
|
||||
slogger->get_start_file_id(start_id, 5);
|
||||
ASSERT_EQ(1, start_id);
|
||||
|
||||
slogger->destroy();
|
||||
SLOGGERMGR.destroy();
|
||||
}
|
||||
|
||||
TEST_F (TestStorageLoggerManager, test_build_item)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
SLOGGERMGR.init(dir_, MAX_FILE_SIZE, log_file_spec_);
|
||||
|
||||
ObStorageLogger *tmp_slogger = OB_NEW(ObStorageLogger, ObModIds::TEST);
|
||||
ASSERT_EQ(OB_SUCCESS, tmp_slogger->init(SLOGGERMGR, 500));
|
||||
ASSERT_EQ(OB_SUCCESS, tmp_slogger->start());
|
||||
|
||||
ObTenantBase tenant_base(5);
|
||||
tenant_base.set(tmp_slogger);
|
||||
ObTenantEnv::set_tenant(&tenant_base);
|
||||
ASSERT_EQ(OB_SUCCESS, tenant_base.init());
|
||||
|
||||
ObTenantSwitchGuard guard;
|
||||
guard.switch_to(5);
|
||||
ObStorageLogger *slogger = MTL(ObStorageLogger*);
|
||||
slogger->start_log(start_cursor_);
|
||||
|
||||
ObStorageLogParam slog_param;
|
||||
ObStorageLogItem *log_item;
|
||||
slog_param.cmd_ = 33;
|
||||
|
||||
ObStorageLogBatchHeader dummy_header;
|
||||
ObStorageLogEntry dummy_entry;
|
||||
int64_t data_len;
|
||||
int64_t buf_size;
|
||||
|
||||
|
||||
// test build single-param normal-size item
|
||||
SimpleObSlog simple_slog1(12, 'A');
|
||||
slog_param.data_ = &simple_slog1;
|
||||
ret = slogger->build_log_item(slog_param, log_item);
|
||||
ASSERT_EQ(OB_SUCCESS, ret);
|
||||
ASSERT_EQ(MAX_CONCURRENT_ITEM_CNT - 1, SLOGGERMGR.slog_items_.get_curr_total());
|
||||
ASSERT_EQ(MAX_CONCURRENT_ITEM_CNT - 1, SLOGGERMGR.log_buffers_.get_curr_total());
|
||||
data_len = dummy_header.get_serialize_size() +
|
||||
dummy_entry.get_serialize_size() +
|
||||
12;
|
||||
buf_size = 512<<10;
|
||||
ASSERT_EQ(data_len, log_item->get_data_len());
|
||||
ASSERT_EQ(data_len, log_item->get_log_data_len());
|
||||
ASSERT_EQ(buf_size, log_item->get_buf_size());
|
||||
|
||||
// free item
|
||||
ret = SLOGGERMGR.free_item(log_item);
|
||||
ASSERT_EQ(OB_SUCCESS, ret);
|
||||
ASSERT_EQ(MAX_CONCURRENT_ITEM_CNT, SLOGGERMGR.slog_items_.get_curr_total());
|
||||
ASSERT_EQ(MAX_CONCURRENT_ITEM_CNT, SLOGGERMGR.log_buffers_.get_curr_total());
|
||||
|
||||
// test build single-param large-size item
|
||||
SimpleObSlog simple_slog2(512<<10, 't');
|
||||
slog_param.data_ = &simple_slog2;
|
||||
ret = slogger->build_log_item(slog_param, log_item);
|
||||
ASSERT_EQ(OB_SUCCESS, ret);
|
||||
ASSERT_EQ(MAX_CONCURRENT_ITEM_CNT - 1, SLOGGERMGR.slog_items_.get_curr_total());
|
||||
ASSERT_EQ(MAX_CONCURRENT_ITEM_CNT, SLOGGERMGR.log_buffers_.get_curr_total());
|
||||
data_len = dummy_header.get_serialize_size() +
|
||||
dummy_entry.get_serialize_size() +
|
||||
(512<<10);
|
||||
int64_t unaligned_size = data_len +
|
||||
dummy_header.get_serialize_size() +
|
||||
dummy_entry.get_serialize_size() +
|
||||
ObLogConstants::LOG_FILE_ALIGN_SIZE;
|
||||
buf_size = upper_align(unaligned_size, ObLogConstants::LOG_FILE_ALIGN_SIZE);
|
||||
ASSERT_EQ(data_len, log_item->get_data_len());
|
||||
ASSERT_EQ(data_len, log_item->get_log_data_len());
|
||||
ASSERT_EQ(buf_size, log_item->get_buf_size());
|
||||
|
||||
// free item
|
||||
ret = SLOGGERMGR.free_item(log_item);
|
||||
ASSERT_EQ(OB_SUCCESS, ret);
|
||||
ASSERT_EQ(MAX_CONCURRENT_ITEM_CNT, SLOGGERMGR.slog_items_.get_curr_total());
|
||||
ASSERT_EQ(MAX_CONCURRENT_ITEM_CNT, SLOGGERMGR.log_buffers_.get_curr_total());
|
||||
|
||||
ObStorageLogParam slog_param_batch1;
|
||||
slog_param_batch1.cmd_ = 39;
|
||||
ObStorageLogParam slog_param_batch2;
|
||||
slog_param_batch2.cmd_ = 39;
|
||||
ObStorageLogParam slog_param_batch3;
|
||||
slog_param_batch3.cmd_ = 39;
|
||||
ObSEArray<ObStorageLogParam, 3> param_arr;
|
||||
// test build batch-param item
|
||||
SimpleObSlog simple_slog_batch1(32, 'a');
|
||||
slog_param_batch1.data_ = &simple_slog_batch1;
|
||||
SimpleObSlog simple_slog_batch2(78, 'z');
|
||||
slog_param_batch2.data_ = &simple_slog_batch2;
|
||||
SimpleObSlog simple_slog_batch3(1, 'd');
|
||||
slog_param_batch3.data_ = &simple_slog_batch3;
|
||||
param_arr.push_back(slog_param_batch1);
|
||||
param_arr.push_back(slog_param_batch2);
|
||||
param_arr.push_back(slog_param_batch3);
|
||||
ret = slogger->build_log_item(param_arr, log_item);
|
||||
ASSERT_EQ(OB_SUCCESS, ret);
|
||||
ASSERT_EQ(MAX_CONCURRENT_ITEM_CNT - 1, SLOGGERMGR.slog_items_.get_curr_total());
|
||||
ASSERT_EQ(MAX_CONCURRENT_ITEM_CNT - 1, SLOGGERMGR.log_buffers_.get_curr_total());
|
||||
data_len = dummy_header.get_serialize_size() +
|
||||
3 * dummy_entry.get_serialize_size() +
|
||||
111;
|
||||
buf_size = 512<<10;
|
||||
ASSERT_EQ(data_len, log_item->get_data_len());
|
||||
ASSERT_EQ(data_len, log_item->get_log_data_len());
|
||||
ASSERT_EQ(buf_size, log_item->get_buf_size());
|
||||
|
||||
// free item
|
||||
ret = SLOGGERMGR.free_item(log_item);
|
||||
ASSERT_EQ(OB_SUCCESS, ret);
|
||||
ASSERT_EQ(MAX_CONCURRENT_ITEM_CNT, SLOGGERMGR.slog_items_.get_curr_total());
|
||||
ASSERT_EQ(MAX_CONCURRENT_ITEM_CNT, SLOGGERMGR.log_buffers_.get_curr_total());
|
||||
|
||||
slogger->destroy();
|
||||
SLOGGERMGR.destroy();
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
system("rm -f test_storage_logger_manager.log*");
|
||||
OB_LOGGER.set_file_name("test_storage_logger_manager.log", true);
|
||||
OB_LOGGER.set_log_level("INFO");
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
Reference in New Issue
Block a user