136 lines
4.5 KiB
C++
136 lines
4.5 KiB
C++
/**
|
|
* 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/container/ob_array.h"
|
|
#include "lib/stat/ob_diagnose_info.h"
|
|
#define private public
|
|
#include "share/ob_tenant_mgr.h"
|
|
#include "blocksstable/ob_row_generate.h"
|
|
#include "blocksstable/ob_data_file_prepare.h"
|
|
#include "storage/ob_pg_meta_checkpoint_writer.h"
|
|
#include "storage/ob_pg_meta_checkpoint_reader.h"
|
|
#include "storage/ob_pg_macro_meta_checkpoint_writer.h"
|
|
#include "storage/ob_pg_macro_meta_checkpoint_reader.h"
|
|
#undef private
|
|
|
|
namespace oceanbase {
|
|
using namespace blocksstable;
|
|
using namespace common;
|
|
using namespace storage;
|
|
using namespace share::schema;
|
|
|
|
namespace unittest {
|
|
|
|
class TestCheckpoint : public TestDataFilePrepare {
|
|
public:
|
|
TestCheckpoint();
|
|
virtual ~TestCheckpoint() = default;
|
|
virtual void SetUp();
|
|
virtual void TearDown();
|
|
|
|
protected:
|
|
void test_pg_meta_checkpoint(const int64_t meta_size);
|
|
|
|
protected:
|
|
static const int64_t MACRO_BLOCK_SIZE = 128 * 1024;
|
|
common::ObPGKey pg_key_;
|
|
};
|
|
|
|
TestCheckpoint::TestCheckpoint()
|
|
: TestDataFilePrepare("checkpoint_test", MACRO_BLOCK_SIZE), pg_key_(combine_id(1, 1000), 0, 0)
|
|
{}
|
|
|
|
void TestCheckpoint::SetUp()
|
|
{
|
|
TestDataFilePrepare::SetUp();
|
|
}
|
|
|
|
void TestCheckpoint::TearDown()
|
|
{
|
|
TestDataFilePrepare::TearDown();
|
|
}
|
|
|
|
void TestCheckpoint::test_pg_meta_checkpoint(const int64_t meta_size)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
const int64_t MAX_TEST_SIZE = 16 * MACRO_BLOCK_SIZE;
|
|
const ObAddr self_addr(ObAddr::IPV4, "127.0.0.01", 80);
|
|
ObArenaAllocator allocator(ObModIds::TEST);
|
|
char* buf = nullptr;
|
|
buf = static_cast<char*>(allocator.alloc(MAX_TEST_SIZE));
|
|
ASSERT_NE(nullptr, buf);
|
|
for (int64_t i = 0; i < MAX_TEST_SIZE; ++i) {
|
|
buf[i] = i % 128;
|
|
}
|
|
ObPGMetaItem item;
|
|
ObPGMetaItemBuffer read_item;
|
|
ASSERT_TRUE(meta_size <= MAX_TEST_SIZE);
|
|
item.set_serialize_buf(buf, meta_size);
|
|
ObPGMetaItemWriter item_writer;
|
|
ObPGMetaCheckpointWriter writer;
|
|
ObPGMetaCheckpointReader reader;
|
|
blocksstable::ObSuperBlockMetaEntry entry;
|
|
ObStorageFile* file = nullptr;
|
|
ObStoreFileSystem& file_system = get_file_system();
|
|
ASSERT_EQ(OB_SUCCESS, file_system.alloc_file(file));
|
|
ASSERT_EQ(OB_SUCCESS, file->init(self_addr, 1, 0, ObStorageFile::FileType::TENANT_DATA));
|
|
ObStorageFileHandle file_handle;
|
|
ObStorageFileWithRef file_with_ref;
|
|
file_with_ref.file_ = file;
|
|
file_handle.set_storage_file_with_ref(file_with_ref);
|
|
ASSERT_EQ(OB_SUCCESS, item_writer.init(file_handle));
|
|
ASSERT_EQ(OB_SUCCESS, writer.init(item, item_writer));
|
|
ASSERT_EQ(OB_SUCCESS, writer.write_checkpoint());
|
|
ASSERT_EQ(OB_SUCCESS, item_writer.close());
|
|
ASSERT_EQ(OB_SUCCESS, item_writer.get_entry_block_index(entry.macro_block_id_));
|
|
ASSERT_TRUE(entry.macro_block_id_.is_valid());
|
|
STORAGE_LOG(INFO, "entry_block", K(entry));
|
|
|
|
ObPartitionMetaRedoModule pg_mgr;
|
|
ASSERT_EQ(OB_SUCCESS, reader.init(entry.macro_block_id_, file_handle, pg_mgr));
|
|
ASSERT_EQ(OB_SUCCESS, reader.read_item(read_item));
|
|
STORAGE_LOG(INFO, "read_item", K(read_item));
|
|
ASSERT_EQ(item.buf_len_, read_item.buf_len_);
|
|
for (int64_t i = 0; i < read_item.buf_len_; ++i) {
|
|
STORAGE_LOG(INFO, "compare item", K(i));
|
|
ASSERT_EQ(item.buf_[i], read_item.buf_[i]);
|
|
}
|
|
int cmp = memcmp(item.buf_, read_item.buf_, item.buf_len_);
|
|
ASSERT_EQ(0, cmp);
|
|
}
|
|
|
|
TEST_F(TestCheckpoint, test_pg_meta_checkpoint)
|
|
{
|
|
test_pg_meta_checkpoint(MACRO_BLOCK_SIZE / 2);
|
|
test_pg_meta_checkpoint(MACRO_BLOCK_SIZE / 4 * 3);
|
|
test_pg_meta_checkpoint(MACRO_BLOCK_SIZE - 50);
|
|
test_pg_meta_checkpoint(MACRO_BLOCK_SIZE);
|
|
test_pg_meta_checkpoint(2 * MACRO_BLOCK_SIZE);
|
|
test_pg_meta_checkpoint(3 * MACRO_BLOCK_SIZE);
|
|
test_pg_meta_checkpoint(6 * MACRO_BLOCK_SIZE);
|
|
test_pg_meta_checkpoint(8 * MACRO_BLOCK_SIZE);
|
|
test_pg_meta_checkpoint(12 * MACRO_BLOCK_SIZE);
|
|
}
|
|
|
|
} // end namespace unittest
|
|
} // end namespace oceanbase
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
system("rm -f test_pg_meta_checkpoint.log*");
|
|
// OB_LOGGER.set_file_name("test_pg_meta_checkpoint.log", true, false);
|
|
// OB_LOGGER.set_log_level("INFO");
|
|
testing::InitGoogleTest(&argc, argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|