140 lines
4.1 KiB
C++
140 lines
4.1 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.
|
|
*/
|
|
|
|
#define USING_LOG_PREFIX STORAGE
|
|
#include <gtest/gtest.h>
|
|
#define private public
|
|
#define protected public
|
|
|
|
#include "storage/backup/ob_backup_tmp_file.h"
|
|
#include "storage/backup/ob_backup_data_struct.h"
|
|
#include "storage/backup/ob_backup_index_cache.h"
|
|
#include "storage/blocksstable/ob_data_file_prepare.h"
|
|
#include "lib/random/ob_random.h"
|
|
#include "test_backup.h"
|
|
|
|
using namespace oceanbase;
|
|
using namespace oceanbase::common;
|
|
using namespace oceanbase::share;
|
|
using namespace oceanbase::backup;
|
|
|
|
namespace oceanbase {
|
|
namespace backup {
|
|
|
|
static ObSimpleMemLimitGetter getter;
|
|
|
|
class TestBackupIndexCache : public ::testing::Test {
|
|
public:
|
|
TestBackupIndexCache();
|
|
virtual ~TestBackupIndexCache();
|
|
virtual void SetUp();
|
|
virtual void TearDown();
|
|
|
|
protected:
|
|
int64_t lower_mem_limit_;
|
|
int64_t upper_mem_limit_;
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(TestBackupIndexCache);
|
|
};
|
|
|
|
TestBackupIndexCache::TestBackupIndexCache() : lower_mem_limit_(8 * 1024 * 1024), upper_mem_limit_(16 * 1024 * 1024)
|
|
{}
|
|
|
|
TestBackupIndexCache::~TestBackupIndexCache()
|
|
{}
|
|
|
|
void TestBackupIndexCache::SetUp()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
const int64_t bucket_num = 1024;
|
|
const int64_t max_cache_size = 1024 * 1024 * 1024;
|
|
const int64_t block_size = lib::ACHUNK_SIZE;
|
|
const uint64_t tenant_id = 1002;
|
|
ret = getter.add_tenant(tenant_id, lower_mem_limit_, upper_mem_limit_);
|
|
ret = ObKVGlobalCache::get_instance().init(&getter, bucket_num, max_cache_size, block_size);
|
|
if (OB_INIT_TWICE == ret) {
|
|
ret = OB_SUCCESS;
|
|
}
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
|
|
CHUNK_MGR.set_limit(5L * 1024L * 1024L * 1024L);
|
|
ret = OB_BACKUP_INDEX_CACHE.init();
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
}
|
|
|
|
void TestBackupIndexCache::TearDown()
|
|
{
|
|
OB_BACKUP_INDEX_CACHE.destroy();
|
|
ObKVGlobalCache::get_instance().destroy();
|
|
getter.reset();
|
|
}
|
|
|
|
static bool cmp_backup_index_cache_value(const ObBackupIndexCacheValue *lhs, const ObBackupIndexCacheValue *rhs)
|
|
{
|
|
bool bret = true;
|
|
if (OB_ISNULL(lhs) || OB_ISNULL(rhs)) {
|
|
bret = false;
|
|
LOG_WARN("lhs or rhs is null", KP(lhs), KP(rhs));
|
|
} else if (lhs->len() != rhs->len()) {
|
|
bret = false;
|
|
LOG_WARN("lhs and rhs not equal", K(lhs), K(rhs));
|
|
} else {
|
|
const int64_t len = lhs->len();
|
|
const char *lhs_buf = lhs->buf();
|
|
const char *rhs_buf = rhs->buf();
|
|
for (int64_t i = 0; i < len; ++i) {
|
|
if (lhs_buf[i] != rhs_buf[i]) {
|
|
bret = false;
|
|
LOG_WARN("buf content is not same", K(lhs_buf[i]), K(rhs_buf[i]), K(i));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return bret;
|
|
}
|
|
|
|
TEST_F(TestBackupIndexCache, put_and_read_cache)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObBackupIndexCacheKey cache_key;
|
|
make_random_cache_key(cache_key);
|
|
ObKVCacheHandle cache_handle;
|
|
const ObBackupIndexCacheValue *new_cache_value = NULL;
|
|
ret = OB_BACKUP_INDEX_CACHE.get(cache_key, new_cache_value, cache_handle);
|
|
EXPECT_EQ(OB_ENTRY_NOT_EXIST, ret);
|
|
const int64_t buf_len = 16 * 1024;
|
|
char *buf = new char[buf_len];
|
|
for (int64_t i = 0; i < buf_len; ++i) {
|
|
buf[i] = static_cast<char>(i % 256);
|
|
}
|
|
ObBackupIndexCacheValue cache_value(buf, buf_len);
|
|
ret = OB_BACKUP_INDEX_CACHE.put(cache_key, cache_value);
|
|
EXPECT_EQ(OB_SUCCESS, ret);
|
|
ret = OB_BACKUP_INDEX_CACHE.get(cache_key, new_cache_value, cache_handle);
|
|
EXPECT_EQ(OB_SUCCESS, ret);
|
|
cmp_backup_index_cache_value(&cache_value, new_cache_value);
|
|
}
|
|
|
|
} // namespace backup
|
|
} // namespace oceanbase
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
system("rm -f test_backup_index_cache.log*");
|
|
ObLogger &logger = ObLogger::get_logger();
|
|
logger.set_file_name("test_backup_index_cache.log", true);
|
|
logger.set_log_level("info");
|
|
testing::InitGoogleTest(&argc, argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|