hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

patch 4.0

Browse Source
This commit is contained in:
wangzelin.wzl
2022-10-24 10:34:53 +08:00
parent 4ad6e00ec3
commit 93a1074b0c
10533 changed files with 2588271 additions and 2299373 deletions
Download Patch File Download Diff File Expand all files Collapse all files

321
unittest/share/test_storage_file.cpp
View File

@ -12,29 +12,32 @@
#define protected public
#include "lib/restore/ob_storage.h"
#ifdef _WITH_OSS
#include "lib/restore/ob_storage_oss_base.cpp"
#endif
#undef protected
#include "lib/profile/ob_trace_id.h"
#include <gtest/gtest.h>
#include "lib/utility/ob_test_util.h"
#include "lib/thread/ob_dynamic_thread_pool.h"
#include "share/backup/ob_backup_io_adapter.h"
#include "common/storage/ob_fd_simulator.h"
#include "share/ob_device_manager.h"
#include "share/backup/ob_backup_struct.h"
using namespace oceanbase::common;
class TestStorageFile : public ::testing::Test {
using namespace oceanbase::share;
class TestStorageFile: public ::testing::Test
{
public:
TestStorageFile()
{}
virtual ~TestStorageFile()
{}
TestStorageFile() {}
virtual ~TestStorageFile(){}
virtual void SetUp()
{
ASSERT_EQ(OB_SUCCESS, databuff_printf(test_dir_, sizeof(test_dir_), "%s/test_storage", get_current_dir_name()));
ASSERT_EQ(OB_SUCCESS, databuff_printf(test_dir_uri_, sizeof(test_dir_uri_), "file://%s", test_dir_));
ASSERT_EQ(OB_SUCCESS,
databuff_printf(test_dir_, sizeof(test_dir_), "%s/test_storage",
get_current_dir_name()));
ASSERT_EQ(OB_SUCCESS,
databuff_printf(test_dir_uri_, sizeof(test_dir_uri_), "file://%s", test_dir_));
STORAGE_LOG(INFO, "clean test_storageg dir");
ASSERT_EQ(0, ::system("rm -fr test_storage"));
}
@ -45,15 +48,15 @@ public:
}
static void SetUpTestCase()
{}
{
}
static void TearDownTestCase()
{}
{
}
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(TestStorageFile);
protected:
// function members
protected:
@ -63,225 +66,194 @@ protected:
TEST_F(TestStorageFile, test_util)
{
ObStorageUtil util(0 /*0s*/, 0 /*0s*/);
ObBackupIoAdapter util;
char uri[OB_MAX_URI_LENGTH];
const ObString storage_info;
ObBackupStorageInfo storage_info;
storage_info.device_type_ = ObStorageType::OB_STORAGE_FILE;
bool is_exist = false;
bool is_empty_dir = false;
char test_content[OB_MAX_URI_LENGTH] = "just_for_test";
char read_buf[OB_MAX_URI_LENGTH];
int64_t read_size = 0;
ASSERT_EQ(OB_SUCCESS, util.mkdir(test_dir_uri_, storage_info));
ASSERT_EQ(OB_SUCCESS, util.is_empty_directory(test_dir_uri_, storage_info, is_empty_dir));
ASSERT_EQ(OB_SUCCESS, util.mkdir(test_dir_uri_, &storage_info));
ASSERT_EQ(OB_SUCCESS, util.is_empty_directory(test_dir_uri_, &storage_info, is_empty_dir));
ASSERT_TRUE(is_empty_dir);
ASSERT_EQ(OB_SUCCESS, databuff_printf(uri, sizeof(uri), "file://%s/test_file", test_dir_));
ASSERT_EQ(OB_SUCCESS, util.is_exist(uri, storage_info, is_exist));
ASSERT_EQ(OB_SUCCESS, util.is_exist(uri, &storage_info, is_exist));
ASSERT_FALSE(is_exist);
ASSERT_EQ(OB_SUCCESS, util.write_single_file(uri, storage_info, test_content, strlen(test_content)));
ASSERT_EQ(OB_SUCCESS, util.get_file_length(uri, storage_info, read_size));
ASSERT_EQ(OB_SUCCESS, util.write_single_file(uri, &storage_info, test_content, strlen(test_content)));
ASSERT_EQ(OB_SUCCESS, util.get_file_length(uri, &storage_info, read_size));
ASSERT_EQ(strlen(test_content), read_size);
ASSERT_EQ(OB_SUCCESS, util.is_exist(uri, storage_info, is_exist));
ASSERT_EQ(OB_SUCCESS, util.is_exist(uri, &storage_info, is_exist));
ASSERT_TRUE(is_exist);
ASSERT_EQ(OB_SUCCESS, util.is_empty_directory(test_dir_uri_, storage_info, is_empty_dir));
ASSERT_EQ(OB_SUCCESS, util.is_empty_directory(test_dir_uri_, &storage_info, is_empty_dir));
ASSERT_FALSE(is_empty_dir);
ASSERT_EQ(OB_SUCCESS, util.del_file(uri, storage_info));
ASSERT_EQ(OB_SUCCESS, util.is_exist(uri, storage_info, is_exist));
ASSERT_EQ(OB_SUCCESS, util.del_file(uri, &storage_info));
ASSERT_EQ(OB_SUCCESS, util.is_exist(uri, &storage_info, is_exist));
ASSERT_FALSE(is_exist);
ASSERT_EQ(OB_SUCCESS, util.write_single_file(uri, storage_info, test_content, strlen(test_content)));
ASSERT_EQ(OB_SUCCESS, util.read_single_file(uri, storage_info, read_buf, sizeof(read_buf), read_size));
ASSERT_EQ(OB_SUCCESS, util.write_single_file(uri, &storage_info, test_content, strlen(test_content)));
ASSERT_EQ(OB_SUCCESS, util.read_single_file(uri, &storage_info, read_buf, sizeof(read_buf), read_size));
ASSERT_EQ(strlen(test_content), read_size);
ASSERT_EQ(0, strncmp(test_content, read_buf, read_size));
ASSERT_EQ(OB_SUCCESS, util.read_single_text_file(uri, storage_info, read_buf, sizeof(read_buf)));
ASSERT_EQ(OB_SUCCESS, util.read_single_text_file(uri, &storage_info, read_buf, sizeof(read_buf)));
ASSERT_EQ(strlen(test_content), strlen(read_buf));
ASSERT_EQ(0, strcmp(test_content, read_buf));
ASSERT_EQ(OB_INVALID_BACKUP_DEST, util.is_exist("bad://", storage_info, is_exist));
ASSERT_EQ(OB_INVALID_BACKUP_DEST, util.get_file_length("bad://", storage_info, read_size));
ASSERT_EQ(OB_INVALID_BACKUP_DEST, util.del_file("bad://", storage_info));
ASSERT_EQ(
OB_INVALID_BACKUP_DEST, util.read_single_file("bad://", storage_info, read_buf, sizeof(read_buf), read_size));
ASSERT_EQ(OB_INVALID_BACKUP_DEST, util.read_single_text_file("bad://", storage_info, read_buf, sizeof(read_buf)));
ASSERT_EQ(OB_INVALID_BACKUP_DEST, util.write_single_file("bad://", storage_info, test_content, strlen(test_content)));
}
TEST_F(TestStorageFile, test_util_retry)
{
const int64_t max_retry_duration = 5 * 1000 * 1000 /*total 5s*/;
ObStorageUtil util(max_retry_duration, 1 * 1000 * 1000 /*sleep 1s*/);
const ObString storage_info;
char test_content[OB_MAX_URI_LENGTH] = "just_for_test";
char read_buf[OB_MAX_URI_LENGTH];
int64_t read_size = 0;
char error_uri[OB_MAX_URI_LENGTH];
ASSERT_EQ(OB_SUCCESS, databuff_printf(error_uri, sizeof(error_uri), "file://%s/test_file/", test_dir_));
ASSERT_EQ(OB_SUCCESS, util.mkdir(test_dir_uri_, storage_info));
int64_t start_ts1 = ObTimeUtil::current_time();
ASSERT_EQ(
OB_INVALID_BACKUP_DEST, util.read_single_file("bad://", storage_info, read_buf, sizeof(read_buf), read_size));
int64_t cost_ts1 = ObTimeUtil::current_time() - start_ts1;
ASSERT_GT(cost_ts1, max_retry_duration);
int64_t start_ts2 = ObTimeUtil::current_time();
ASSERT_EQ(OB_IO_ERROR, util.write_single_file(error_uri, storage_info, test_content, strlen(test_content)));
int64_t cost_ts2 = ObTimeUtil::current_time() - start_ts2;
ASSERT_GT(cost_ts2, max_retry_duration);
ASSERT_EQ(OB_INVALID_BACKUP_DEST, util.is_exist("bad://", &storage_info, is_exist));
ASSERT_EQ(OB_INVALID_BACKUP_DEST, util.get_file_length("bad://", &storage_info, read_size));
ASSERT_EQ(OB_INVALID_BACKUP_DEST, util.del_file("bad://", &storage_info));
ASSERT_EQ(OB_INVALID_BACKUP_DEST, util.read_single_file("bad://", &storage_info, read_buf, sizeof(read_buf), read_size));
ASSERT_EQ(OB_INVALID_BACKUP_DEST, util.read_single_text_file("bad://", &storage_info, read_buf, sizeof(read_buf)));
ASSERT_EQ(OB_INVALID_BACKUP_DEST, util.write_single_file("bad://", &storage_info, test_content, strlen(test_content)));
}
TEST_F(TestStorageFile, test_reader)
{
ObStorageUtil util(0 /*0s*/, 0 /*0s*/);
ObStorageReader reader;
ObStorageReader reader2;
ObBackupIoAdapter util;
char uri[OB_MAX_URI_LENGTH];
const ObString storage_info;
ObBackupStorageInfo storage_info;
storage_info.device_type_ = ObStorageType::OB_STORAGE_FILE;
char test_content[OB_MAX_URI_LENGTH] = "just_for_test";
char read_buf[OB_MAX_URI_LENGTH];
int64_t read_size = 0;
ASSERT_EQ(OB_SUCCESS, util.mkdir(test_dir_uri_, storage_info));
ASSERT_EQ(OB_SUCCESS, util.mkdir(test_dir_uri_, &storage_info));
ASSERT_EQ(OB_SUCCESS, databuff_printf(uri, sizeof(uri), "file://%s/test_file", test_dir_));
ASSERT_EQ(OB_NOT_INIT, reader.pread(read_buf, sizeof(read_buf), 0, read_size));
ASSERT_EQ(OB_INVALID_BACKUP_DEST, reader.open("bad://", storage_info));
ASSERT_EQ(OB_BACKUP_FILE_NOT_EXIST, reader.open(uri, storage_info));
ObIODevice* dev_handle = NULL;
ObIOFd fd;
ObIOFd fd_2;
ASSERT_EQ(OB_SUCCESS, util.write_single_file(uri, storage_info, test_content, strlen(test_content)));
ASSERT_EQ(OB_SUCCESS, reader.open(uri, storage_info));
ASSERT_EQ(OB_INIT_TWICE, reader.open(uri, storage_info));
ASSERT_EQ(OB_NOT_INIT, reader.pread(read_buf, sizeof(read_buf), 0, read_size));
ASSERT_EQ(OB_INVALID_BACKUP_DEST, util.open_with_access_type(dev_handle, fd, &storage_info, "bad://", OB_STORAGE_ACCESS_READER));
ASSERT_EQ(OB_BACKUP_FILE_NOT_EXIST, util.open_with_access_type(dev_handle, fd, &storage_info, uri, OB_STORAGE_ACCESS_READER));
ASSERT_EQ(OB_SUCCESS, util.write_single_file(uri, &storage_info, test_content, strlen(test_content)));
ASSERT_EQ(OB_SUCCESS, reader2.open(uri, storage_info));
ASSERT_EQ(OB_SUCCESS, reader2.pread(read_buf, sizeof(read_buf), 0, read_size));
ASSERT_EQ(OB_SUCCESS, util.open_with_access_type(dev_handle, fd, &storage_info, uri, OB_STORAGE_ACCESS_READER));
ASSERT_EQ(OB_INIT_TWICE, util.open_with_access_type(dev_handle, fd, &storage_info, uri, OB_STORAGE_ACCESS_READER));
//in the old version, use a valid fd to open twice, fd will be closed automatic, this behavir has changed.
//in such scenario, just return error. so here should success.
//difference: OB_NOT_INIT -> OB_SUCCESS
//ASSERT_EQ(OB_NOT_INIT, dev_handle->pread(fd, 0, sizeof(read_buf), read_buf, read_size));
ASSERT_EQ(OB_SUCCESS, dev_handle->pread(fd, 0, sizeof(read_buf), read_buf, read_size));
ASSERT_EQ(OB_SUCCESS, dev_handle->close(fd));
ASSERT_EQ(OB_SUCCESS, util.open_with_access_type(dev_handle, fd_2, &storage_info, uri, OB_STORAGE_ACCESS_READER));
ASSERT_EQ(OB_SUCCESS, dev_handle->pread(fd_2, 0, sizeof(read_buf), read_buf, read_size));
ASSERT_EQ(strlen(test_content), read_size);
ASSERT_EQ(0, strncmp(test_content, read_buf, read_size));
ASSERT_EQ(OB_INVALID_ARGUMENT, reader2.pread(read_buf, sizeof(read_buf), read_size + 1, read_size));
ASSERT_EQ(OB_INVALID_ARGUMENT, reader2.pread(read_buf, sizeof(read_buf), -1, read_size));
ASSERT_EQ(OB_INVALID_ARGUMENT, reader2.pread(NULL, sizeof(read_buf), 0, read_size));
ASSERT_EQ(OB_INVALID_ARGUMENT, reader2.pread(read_buf, 0, 0, read_size));
ASSERT_EQ(OB_SUCCESS, reader2.close());
ASSERT_EQ(OB_NOT_INIT, reader2.close());
ASSERT_EQ(OB_INVALID_ARGUMENT, dev_handle->pread(fd_2, read_size + 1, sizeof(read_buf), read_buf, read_size));
ASSERT_EQ(OB_INVALID_ARGUMENT, dev_handle->pread(fd_2, -1, sizeof(read_buf), read_buf, read_size));
ASSERT_EQ(OB_INVALID_ARGUMENT, dev_handle->pread(fd_2, -1, sizeof(read_buf), NULL, read_size));
ASSERT_EQ(OB_INVALID_ARGUMENT, dev_handle->pread(fd_2, 0, 0, read_buf, read_size));
ASSERT_EQ(OB_SUCCESS, dev_handle->close(fd_2));
ASSERT_EQ(OB_NOT_INIT, dev_handle->close(fd_2));
}
TEST_F(TestStorageFile, test_writer)
{
ObStorageUtil util(0 /*0s*/, 0 /*0s*/);
ObStorageWriter writer;
ObStorageWriter writer2;
ObBackupIoAdapter util;
char uri[OB_MAX_URI_LENGTH];
const ObString storage_info;
ObBackupStorageInfo storage_info;
storage_info.device_type_ = ObStorageType::OB_STORAGE_FILE;
char test_content[OB_MAX_URI_LENGTH] = "just_for_test";
char read_buf[OB_MAX_URI_LENGTH];
ASSERT_EQ(OB_SUCCESS, util.mkdir(test_dir_uri_, storage_info));
int64_t write_size = -1;
ObIODevice* dev_handle = NULL;
ObIOFd fd;
ObIOFd fd_2;
ASSERT_EQ(OB_SUCCESS, util.mkdir(test_dir_uri_, &storage_info));
ASSERT_EQ(OB_SUCCESS, databuff_printf(uri, sizeof(uri), "file://%s/test_file", test_dir_));
ASSERT_EQ(OB_INVALID_BACKUP_DEST, writer.open("bad://", storage_info));
ASSERT_EQ(OB_SUCCESS, writer.open(uri, storage_info));
ASSERT_EQ(OB_INIT_TWICE, writer.open(uri, storage_info));
ASSERT_EQ(OB_SUCCESS, writer2.open(uri, storage_info));
ASSERT_EQ(OB_SUCCESS, writer2.write(read_buf, strlen(test_content)));
ASSERT_EQ(OB_SUCCESS, writer2.close());
ASSERT_EQ(OB_NOT_INIT, writer2.close());
ASSERT_EQ(OB_INVALID_BACKUP_DEST, util.open_with_access_type(dev_handle, fd, &storage_info, "bad://", OB_STORAGE_ACCESS_OVERWRITER));
ASSERT_EQ(OB_SUCCESS, util.open_with_access_type(dev_handle, fd, &storage_info, uri, OB_STORAGE_ACCESS_OVERWRITER));
ASSERT_EQ(OB_INIT_TWICE, util.open_with_access_type(dev_handle, fd, &storage_info, uri, OB_STORAGE_ACCESS_OVERWRITER));
ASSERT_EQ(OB_SUCCESS, dev_handle->close(fd));
ASSERT_EQ(OB_SUCCESS, util.open_with_access_type(dev_handle, fd_2, &storage_info, uri, OB_STORAGE_ACCESS_OVERWRITER));
ASSERT_EQ(OB_SUCCESS, dev_handle->write(fd_2, test_content, strlen(test_content), write_size));
ASSERT_EQ(OB_SUCCESS, dev_handle->close(fd_2));
ASSERT_EQ(OB_NOT_INIT, dev_handle->close(fd_2));
}
TEST_F(TestStorageFile, test_file_writer_fail)
{
ObStorageUtil util(0 /*0s*/, 0 /*0s*/);
ObStorageFileWriter writer;
ObStorageFileWriter writer2;
ObBackupIoAdapter util;
char uri[OB_MAX_URI_LENGTH];
const ObString storage_info;
ObBackupStorageInfo storage_info;
storage_info.device_type_ = ObStorageType::OB_STORAGE_FILE;
char test_content[OB_MAX_URI_LENGTH] = "just_for_test";
char test_content2[OB_MAX_URI_LENGTH] = "just_for_test2";
ASSERT_EQ(OB_SUCCESS, util.mkdir(test_dir_uri_, storage_info));
int64_t write_size = -1;
ObIODevice* dev_handle = NULL;
ObIOFd fd;
ObIOFd fd_2;
ASSERT_EQ(OB_SUCCESS, util.mkdir(test_dir_uri_, &storage_info));
ASSERT_EQ(OB_SUCCESS, databuff_printf(uri, sizeof(uri), "file://%s/test_file", test_dir_));
ASSERT_EQ(OB_SUCCESS, writer.open(uri, storage_info));
ASSERT_EQ(OB_SUCCESS, writer.write(test_content, strlen(test_content)));
ASSERT_EQ(OB_SUCCESS, writer.close());
ASSERT_EQ(OB_SUCCESS, writer2.open(uri, storage_info));
ASSERT_EQ(OB_SUCCESS, writer2.write(test_content2, strlen(test_content2)));
writer2.has_error_ = true;
ASSERT_EQ(OB_SUCCESS, writer2.close());
ASSERT_EQ(OB_SUCCESS, util.open_with_access_type(dev_handle, fd, &storage_info, uri, OB_STORAGE_ACCESS_OVERWRITER));
ASSERT_EQ(OB_SUCCESS, dev_handle->write(fd, test_content, strlen(test_content) , write_size));
ASSERT_EQ(OB_SUCCESS, dev_handle->close(fd));
ASSERT_EQ(OB_SUCCESS, util.open_with_access_type(dev_handle, fd_2, &storage_info, uri, OB_STORAGE_ACCESS_OVERWRITER));
ASSERT_EQ(OB_SUCCESS, dev_handle->write(fd_2, test_content2, strlen(test_content2), write_size));
ASSERT_EQ(OB_SUCCESS, dev_handle->close(fd_2));
char read_buf[OB_MAX_URI_LENGTH];
int64_t read_size = 0;
ASSERT_EQ(OB_SUCCESS, util.read_single_file(uri, storage_info, read_buf, sizeof(read_buf), read_size));
ASSERT_EQ(OB_SUCCESS, util.read_single_file(uri, &storage_info,
read_buf, sizeof(read_buf), read_size));
COMMON_LOG(INFO, "dump buf", K(test_content), K(test_content2), K(read_buf));
ASSERT_EQ(0, MEMCMP(test_content, read_buf, read_size));
}
TEST_F(TestStorageFile, test_meta)
{
ObStorageUtil util(0 /*0s*/, 0 /*0s*/);
ObStorageMetaWrapper meta;
char uri[OB_MAX_URI_LENGTH];
const ObString storage_info;
char test_content[OB_MAX_URI_LENGTH] = "just_for_test";
char read_buf[OB_MAX_URI_LENGTH];
int64_t read_size = 0;
ASSERT_EQ(OB_SUCCESS, databuff_printf(uri, sizeof(uri), "file://%s/test_file", test_dir_));
ASSERT_EQ(OB_SUCCESS, util.mkdir(test_dir_uri_, storage_info));
ASSERT_EQ(OB_BACKUP_FILE_NOT_EXIST, meta.get(uri, storage_info, read_buf, sizeof(read_buf), read_size));
ASSERT_EQ(OB_SUCCESS, meta.set(uri, storage_info, test_content, strlen(test_content)));
ASSERT_EQ(OB_SUCCESS, meta.set(uri, storage_info, test_content, strlen(test_content)));
ASSERT_EQ(OB_SUCCESS, meta.get(uri, storage_info, read_buf, sizeof(read_buf), read_size));
ASSERT_EQ(read_size, strlen(test_content));
ASSERT_EQ(OB_INVALID_BACKUP_DEST, meta.get("bad_file:///", storage_info, read_buf, sizeof(read_buf), read_size));
ASSERT_EQ(OB_INVALID_BACKUP_DEST, meta.set("bad_file:///", storage_info, test_content, strlen(test_content)));
//comment by zhangyi, now we can not just used storage api to change has_error_;
//ASSERT_EQ(0, MEMCMP(test_content, read_buf, read_size));
}
TEST_F(TestStorageFile, test_mkdir)
{
ObStorageUtil util(0 /*0s*/, 0 /*0s*/);
ObBackupIoAdapter util;
char uri[OB_MAX_URI_LENGTH];
const ObString storage_info;
ObBackupStorageInfo storage_info;
storage_info.device_type_ = ObStorageType::OB_STORAGE_FILE;
bool is_exist = false;
ASSERT_EQ(OB_SUCCESS, databuff_printf(uri, sizeof(uri), "file://%s/nfs/test/ob/7/1001/113415412451/0", test_dir_));
ASSERT_EQ(OB_SUCCESS, util.mkdir(uri, storage_info));
ASSERT_EQ(OB_SUCCESS, util.is_exist(uri, storage_info, is_exist));
ASSERT_EQ(OB_SUCCESS, util.mkdir(uri, &storage_info));
ASSERT_EQ(OB_SUCCESS, util.is_exist(uri, &storage_info, is_exist));
ASSERT_TRUE(is_exist);
ASSERT_EQ(OB_SUCCESS, util.del_dir(uri, &storage_info));
}
TEST_F(TestStorageFile, test_parallel_mkdir)
{
class MakedirTask : public ObDynamicThreadTask {
class MakedirTask: public ObDynamicThreadTask
{
public:
int init(const char* dir)
int init(const char *dir)
{
EXPECT_FALSE(NULL == dir);
int64_t timestamp = ObTimeUtility::current_time();
EXPECT_EQ(OB_SUCCESS,
databuff_printf(
uri_, OB_MAX_URI_LENGTH, "file://%s/%ld/nfs/test/parallel/mkdir/1/2/3/4/5/6/7/8", dir, timestamp));
EXPECT_EQ(OB_SUCCESS, databuff_printf(uri_, OB_MAX_URI_LENGTH,
"file://%s/%ld/nfs/test/parallel/mkdir/1/2/3/4/5/6/7/8",
dir, timestamp));
return OB_SUCCESS;
}
int process(const bool& is_stop)
int process(const bool &is_stop)
{
UNUSED(is_stop);
ObStorageUtil util(0 /*0s*/, 0 /*0s*/);
const ObString storage_info;
ObBackupIoAdapter util;
ObBackupStorageInfo storage_info;
storage_info.device_type_ = ObStorageType::OB_STORAGE_FILE;
bool is_exist = false;
EXPECT_EQ(OB_SUCCESS, util.mkdir(uri_, storage_info));
EXPECT_EQ(OB_SUCCESS, util.is_exist(uri_, storage_info, is_exist));
EXPECT_EQ(OB_SUCCESS, util.mkdir(uri_, &storage_info));
EXPECT_EQ(OB_SUCCESS, util.is_exist(uri_, &storage_info, is_exist));
EXPECT_TRUE(is_exist);
return OB_SUCCESS;
}
private:
char uri_[OB_MAX_URI_LENGTH];
};
@ -301,60 +273,11 @@ TEST_F(TestStorageFile, test_parallel_mkdir)
pool.destroy();
}
TEST_F(TestStorageFile, test_get_pkeys_from_dir)
{
ObStorageUtil util(0 /*0s*/, 0 /*0s*/);
const ObString storage_info;
char uri[OB_MAX_URI_LENGTH];
char dir_uri[OB_MAX_URI_LENGTH];
char dir_name[OB_MAX_URI_LENGTH];
const int64_t ts = ObTimeUtility::current_time();
// format dir path uri
ASSERT_EQ(OB_SUCCESS, databuff_printf(dir_name, sizeof(dir_name), "test_get_pkeys_from_dir/%ld", ts));
ASSERT_EQ(OB_SUCCESS, databuff_printf(dir_uri, sizeof(dir_uri), "%s/%s", test_dir_uri_, dir_name));
char buffer[1024] = "abcdefghijklmnopqrstuvwxyz";
ASSERT_EQ(OB_SUCCESS, util.mkdir(dir_uri, storage_info));
// create 10 partitions
constexpr int partitions_cnt = 10;
for (int i = 0; i < partitions_cnt; i++) {
// format object path uri
ASSERT_EQ(OB_SUCCESS, databuff_printf(uri, sizeof(uri), "%s/%ld_%d", dir_uri, ts, i));
ASSERT_EQ(OB_SUCCESS, util.write_single_file(uri, storage_info, buffer, sizeof(buffer)));
}
// create 10 tmp partition key file
for (int i = 0; i < partitions_cnt; i++) {
// format object path uri %s.tmp.%ld
ASSERT_EQ(OB_SUCCESS, databuff_printf(uri, sizeof(uri), "%s/%ld_%d.tmp.%ld", dir_uri, ts, i, ts));
ASSERT_EQ(OB_SUCCESS, util.write_single_file(uri, storage_info, buffer, sizeof(buffer)));
}
ObArray<ObPartitionKey> pkeys;
ASSERT_EQ(OB_SUCCESS, util.get_pkeys_from_dir(dir_uri, storage_info, pkeys));
bool flags[partitions_cnt] = {false};
ASSERT_EQ(partitions_cnt, pkeys.count());
for (int i = 0; i < partitions_cnt; i++) {
ASSERT_EQ(ts, pkeys[i].get_table_id());
uint64_t pid = pkeys[i].get_partition_id();
ASSERT_FALSE(flags[pid]);
flags[pid] = true;
}
}
int main(int argc, char** argv)
int main(int argc, char **argv)
{
system("rm -f test_storage_file.log");
OB_LOGGER.set_file_name("test_storage_file.log");
OB_LOGGER.set_log_level("INFO");
::testing::InitGoogleTest(&argc, argv);
::testing::InitGoogleTest(&argc,argv);
return RUN_ALL_TESTS();
}