init push

unittest/storage/test_pg_meta_checkpoint.cpp

@@ -0,0 +1,135 @@
+/**
+ * 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();
+}