hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
dffd24c77f252f2020d90401ff4924fdb65746e3
oceanbase/unittest/rootserver/test_recovery_helper.cpp
gm 4a92b6d7df reformat source code 
according to code styles, 'AccessModifierOffset' should be -2.
2021-06-17 10:40:36 +08:00

403 lines
16 KiB
C++
Raw Blame History

/**
* 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 RS
#include "gtest/gtest.h"
#include "gmock/gmock.h"
//#include "../share/schema/db_initializer.h"
#include "rootserver/ob_recovery_helper.h"
//#include "share/ob_remote_sql_proxy.h"
#include "../share/partition_table/fake_part_property_getter.h" // for A,B,C,D,E
//#include "../share/partition_table/fake_partition_table_operator.h"
//#include "../share/partition_table/fake_schema_service.h"
//#include "share/partition_table/ob_partition_table_operator.h"
//#include "share/schema/ob_schema_getter_guard.h"
//#include "share/schema/ob_multi_version_schema_service.h"
//#include "rootserver/ob_server_manager.h"
//#include "rootserver/ob_zone_manager.h"
#include "share/schema/ob_schema_test_utils.cpp"
//#include "lib/hash/ob_hashset.h"
namespace oceanbase {
using namespace common;
using namespace share;
using namespace share::schema;
using namespace share::host;
using namespace common::hash;
namespace rootserver {
// class FakeSchemaService : public MockSchemaService
//{
// public:
// const static int64_t SCHEMA_VERSION = 1;
// const static int64_t USR_SCHEMA_VERSION = 2;
//
// int init() { return MockSchemaService::init(); }
// virtual int gen_tenant_schema(const uint64_t tenant_id, ObTenantSchema &tenant_schema);
// virtual int gen_sys_variable(const uint64_t tenant_id, ObSysVariableSchema &sys_variable);
// virtual int gen_table_schema(const uint64_t tenant_id, const uint64_t pure_id,
// const uint64_t pure_db_id, const uint64_t pure_tg_id,
// ObTableSchema &table_schema);
// virtual int get_schema_guard(ObSchemaGetterGuard &guard,
// int64_t schema_version = common::OB_INVALID_VERSION,
// const bool force_fallback = false)
// {
// UNUSED(force_fallback);
// UNUSED(schema_version);
// return MockSchemaService::get_schema_guard(guard, schema_version);
// }
// int add_tenant(ObTenantSchema &tenant_schema)
// {
// tenant_schema.set_schema_version(SCHEMA_VERSION);
// return MockSchemaService::add_tenant_schema(tenant_schema, SCHEMA_VERSION);
// }
// int add_table(ObTableSchema &table_schema)
// {
// table_schema.set_schema_version(SCHEMA_VERSION);
// return MockSchemaService::add_table_schema(table_schema, SCHEMA_VERSION);
// }
//};
// int FakeSchemaService::gen_tenant_schema(const uint64_t tenant_id, ObTenantSchema &tenant_schema)
//{
// int ret = OB_SUCCESS;
// char tenant_name[64];
// if (snprintf(tenant_name, 64, "tenant_%lu", tenant_id) >= 64) {
// ret = OB_BUF_NOT_ENOUGH;
// SHARE_SCHEMA_LOG(WARN, "buf not enough", K(ret));
// } else {
// tenant_schema.set_tenant_id(tenant_id);
// tenant_schema.set_tenant_name(tenant_name);
// tenant_schema.set_comment("this is a test tenant");
// tenant_schema.add_zone("zone");
// tenant_schema.set_primary_zone("zone");
// tenant_schema.set_locality("auto_locality_strategy");
// }
// return ret;
//}
//
// int FakeSchemaService::gen_sys_variable(const uint64_t tenant_id, ObSysVariableSchema &sys_variable)
//{
// int ret = OB_SUCCESS;
// sys_variable.set_tenant_id(tenant_id);
// if (OB_SYS_TENANT_ID == tenant_id) {
// sys_variable.set_name_case_mode(OB_ORIGIN_AND_INSENSITIVE);
// sys_variable.load_default_system_variable(true);
// } else {
// sys_variable.set_name_case_mode(OB_LOWERCASE_AND_INSENSITIVE);
// sys_variable.load_default_system_variable(false);
// }
// return ret;
//}
//
// int FakeSchemaService::gen_table_schema(const uint64_t tenant_id,
// const uint64_t pure_id,
// const uint64_t pure_db_id,
// const uint64_t pure_tg_id,
// ObTableSchema &table_schema)
//{
// int ret = OB_SUCCESS;
// table_schema.reset();
// ObInnerTableSchema::all_core_table_schema(table_schema);
// char table_name[64];
// if (snprintf(table_name, 64, "table_%lu", combine_id(tenant_id, pure_id)) >= 64) {
// ret = OB_BUF_NOT_ENOUGH;
// SHARE_SCHEMA_LOG(WARN, "buf not enough", K(ret));
// } else {
// table_schema.set_table_name(table_name);
// table_schema.set_tenant_id(tenant_id);
// table_schema.set_table_id(combine_id(tenant_id, pure_id));
// table_schema.set_database_id(combine_id(tenant_id, pure_db_id));
// table_schema.set_tablegroup_id(combine_id(tenant_id, pure_tg_id));
// table_schema.set_locality("R@z1,R@z2,R@z3");
// ObArray<share::ObZoneReplicaNumSet> zone_replica_set;
// for (int64_t i = 0; i < 3; i++) {
// share::ObZoneReplicaNumSet set;
// set.zone_ = ObZone("z1");
// //set.set_replica_num(0, 0, 0, 1, 0);
// zone_replica_set.push_back(set);
// }
// //table_schema.set_zone_replica_num_array(zone_replica_set);
// }
// return ret;
//}
class TestRecoveryHelper : public ::testing::Test {
public:
TestRecoveryHelper()
{}
virtual ~TestRecoveryHelper()
{}
virtual void SetUp();
virtual void TearDown();
// int add_table_schema();
// int add_partition();
int build_partition(int64_t table_id, ObPartitionInfo& partition, int64_t replica_cnt, int64_t pos = 6);
int add_server();
public:
// DBInitializer db_initer_;
// FakePartPropertyGetter prop_getter_;
// FakePartitionTableOperator pt_;
// FakeSchemaService schema_service_;
// schema::ObSchemaGetterGuard schema_guard_;
ObArray<ObAddr> server_list_;
};
int TestRecoveryHelper::add_server()
{
int ret = OB_SUCCESS;
EXPECT_EQ(OB_SUCCESS, server_list_.push_back(A));
EXPECT_EQ(OB_SUCCESS, server_list_.push_back(B));
EXPECT_EQ(OB_SUCCESS, server_list_.push_back(C));
EXPECT_EQ(OB_SUCCESS, server_list_.push_back(D));
EXPECT_EQ(OB_SUCCESS, server_list_.push_back(E));
EXPECT_EQ(OB_SUCCESS, server_list_.push_back(F));
EXPECT_EQ(OB_SUCCESS, server_list_.push_back(G));
return ret;
}
// int TestRecoveryHelper::add_table_schema()
//{
// int ret = OB_SUCCESS;
// ObTableSchema table_schema;
// ObTenantSchema tenant_schema;
// ObSysVariableSchema sys_variable;
// int64_t pure_db_id = 10001;
// int64_t pure_tg_id = 10001;
// int64_t TENANT_CNT = 2;
// int64_t TABLE_CNT = 5;
// {
// int64_t MIN_TENANT_ID = 1001;
// int64_t MIN_TABLE_ID = 50001;
// for (int64_t i = 0; i < TENANT_CNT; i++) {
// int64_t tenant_id = MIN_TENANT_ID + i;
// EXPECT_EQ(OB_SUCCESS, schema_service_.gen_tenant_schema(tenant_id, tenant_schema));
// EXPECT_EQ(OB_SUCCESS, schema_service_.add_tenant(tenant_schema));
// EXPECT_EQ(OB_SUCCESS, schema_service_.gen_sys_variable(tenant_id, sys_variable));
// EXPECT_EQ(OB_SUCCESS, schema_service_.add_sys_variable_schema(sys_variable,
// tenant_schema.get_schema_version())); for (int64_t j = 0; j < TABLE_CNT; j++) {
// int64_t table_id = MIN_TABLE_ID + j;
// EXPECT_EQ(OB_SUCCESS, schema_service_.gen_table_schema(tenant_id, table_id,
// pure_db_id, pure_tg_id,
// table_schema));
// EXPECT_EQ(OB_SUCCESS, schema_service_.add_table(table_schema));
// }
// }
// }
// return ret;
//}
//
int TestRecoveryHelper::build_partition(int64_t table_id, ObPartitionInfo& partition, int64_t replica_cnt, int64_t pos)
{
int ret = OB_SUCCESS;
partition.set_table_id(table_id);
partition.set_partition_id(0);
ObPartitionReplica::MemberList ml;
for (int64_t i = 0; i < replica_cnt; i++) {
ObPartitionReplica replica;
replica.table_id_ = table_id;
replica.partition_id_ = 0;
replica.partition_cnt_ = 1;
replica.server_ = server_list_.at(pos - i);
replica.zone_ = ZONE1;
replica.data_version_ = 2;
replica.member_list_ = ml;
replica.replica_type_ = REPLICA_TYPE_FULL;
if (i == 0) {
replica.role_ = LEADER;
replica.to_leader_time_ = ObTimeUtility::current_time();
}
partition.get_replicas_v2().push_back(replica);
}
return ret;
}
// int TestRecoveryHelper::add_partition()
//{
// int ret = OB_SUCCESS;
// int64_t TENANT_CNT = 2;
// int64_t TABLE_CNT = 5;
// {
// int64_t MIN_TENANT_ID = 1001;
// int64_t MIN_TABLE_ID = 50001;
// for (int64_t i = 0; i < TENANT_CNT; i ++) {
// int64_t tenant_id = MIN_TENANT_ID + i;
// for (int64_t j = 0; j < TABLE_CNT; j++) {
// int64_t table_id = combine_id(tenant_id, MIN_TABLE_ID + j);
// ObPartitionInfo info;
// info.set_table_id(table_id);
// info.set_partition_id(0);
// EXPECT_EQ(OB_SUCCESS, build_partition(table_id, info, 3));
// EXPECT_EQ(OB_SUCCESS, pt_.partitions_.push_back(info));
// }
// }
// }
// return ret;
//}
void TestRecoveryHelper::TearDown()
{
ObKVGlobalCache::get_instance().destroy();
}
void TestRecoveryHelper::SetUp()
{
ObKVGlobalCache::get_instance().init();
add_server();
// ASSERT_EQ(OB_SUCCESS, db_initer_.init());
// schema_service_.init();
// const bool only_core_tables = false;
// ASSERT_EQ(OB_SUCCESS, db_initer_.create_system_table(only_core_tables));
// ASSERT_EQ(OB_SUCCESS, db_initer_.fill_sys_stat_table());
// ASSERT_EQ(OB_SUCCESS, add_table_schema());
// ASSERT_EQ(OB_SUCCESS, add_partition());
}
#define CHECK_RESULT(addr, array_index, member_index) \
ASSERT_EQ( \
OB_SUCCESS, list.ml_pk_array_.at(array_index).member_list_.get_server_by_index(member_index, result_addr)); \
ASSERT_EQ(addr, result_addr);
TEST_F(TestRecoveryHelper, test_member_list)
{
ObRecoveryHelper::ObMemberListPkeyList list;
ObAddr result_addr;
// Add partition has the same member list
int64_t tenant_id = 1001;
for (int64_t i = 0; i < 4; i++) {
int64_t pure_id = 50001 + i;
int64_t table_id = combine_id(tenant_id, pure_id);
int64_t replica_cnt = 3;
int64_t pos = 2;
ObPartitionInfo partition;
ASSERT_EQ(OB_SUCCESS, build_partition(table_id, partition, replica_cnt, pos));
ASSERT_EQ(OB_SUCCESS, list.add_partition(partition));
}
ASSERT_EQ(4, list.pkey_array_.count());
ASSERT_EQ(1, list.ml_pk_array_.count());
ASSERT_EQ(3, list.ml_pk_array_.at(0).member_list_.get_member_number());
CHECK_RESULT(A, 0, 0);
CHECK_RESULT(B, 0, 1);
CHECK_RESULT(C, 0, 2);
// ASSERT_EQ(A, list.ml_pk_array_.at(0).member_list_.at(0));
// ASSERT_EQ(B, list.ml_pk_array_.at(0).member_list_.at(1));
// ASSERT_EQ(C, list.ml_pk_array_.at(0).member_list_.at(2));
// Add partition has different member list
for (int64_t i = 0; i < 4; i++) {
int64_t pure_id = 50004 + i;
int64_t table_id = combine_id(tenant_id, pure_id);
int64_t replica_cnt = 2;
int64_t pos = 5;
ObPartitionInfo partition;
ASSERT_EQ(OB_SUCCESS, build_partition(table_id, partition, replica_cnt, pos));
ASSERT_EQ(OB_SUCCESS, list.add_partition(partition));
}
ASSERT_EQ(8, list.pkey_array_.count());
ASSERT_EQ(2, list.ml_pk_array_.count());
ASSERT_EQ(3, list.ml_pk_array_.at(0).member_list_.get_member_number());
// ASSERT_EQ(A, list.ml_pk_array_.at(0).member_list_.at(0));
// ASSERT_EQ(B, list.ml_pk_array_.at(0).member_list_.at(1));
// ASSERT_EQ(C, list.ml_pk_array_.at(0).member_list_.at(2));
CHECK_RESULT(A, 0, 0);
CHECK_RESULT(B, 0, 1);
CHECK_RESULT(C, 0, 2);
ASSERT_EQ(2, list.ml_pk_array_.at(1).member_list_.get_member_number());
// ASSERT_EQ(E, list.ml_pk_array_.at(1).member_list_.at(0));
// ASSERT_EQ(F, list.ml_pk_array_.at(1).member_list_.at(1));
CHECK_RESULT(E, 1, 0);
CHECK_RESULT(F, 1, 1);
for (int64_t i = 0; i < 4; i++) {
int64_t pure_id = 50008 + i;
int64_t table_id = combine_id(tenant_id, pure_id);
int64_t replica_cnt = 4;
int64_t pos = 3;
ObPartitionInfo partition;
ASSERT_EQ(OB_SUCCESS, build_partition(table_id, partition, replica_cnt, pos));
ASSERT_EQ(OB_SUCCESS, list.add_partition(partition));
}
ASSERT_EQ(12, list.pkey_array_.count());
ASSERT_EQ(3, list.ml_pk_array_.count());
ASSERT_EQ(3, list.ml_pk_array_.at(0).member_list_.get_member_number());
// ASSERT_EQ(A, list.ml_pk_array_.at(0).member_list_.at(0));
// ASSERT_EQ(B, list.ml_pk_array_.at(0).member_list_.at(1));
// ASSERT_EQ(C, list.ml_pk_array_.at(0).member_list_.at(2));
CHECK_RESULT(A, 0, 0);
CHECK_RESULT(B, 0, 1);
CHECK_RESULT(C, 0, 2);
ASSERT_EQ(2, list.ml_pk_array_.at(1).member_list_.get_member_number());
// ASSERT_EQ(E, list.ml_pk_array_.at(1).member_list_.at(0));
// ASSERT_EQ(F, list.ml_pk_array_.at(1).member_list_.at(1));
CHECK_RESULT(E, 1, 0);
CHECK_RESULT(F, 1, 1);
ASSERT_EQ(4, list.ml_pk_array_.at(2).member_list_.get_member_number());
CHECK_RESULT(A, 2, 0);
CHECK_RESULT(B, 2, 1);
CHECK_RESULT(C, 2, 2);
CHECK_RESULT(D, 2, 3);
// Add the partition of the same member list again
for (int64_t i = 0; i < 4; i++) {
int64_t pure_id = 50010 + i;
int64_t table_id = combine_id(tenant_id, pure_id);
int64_t replica_cnt = 3;
int64_t pos = 2;
ObPartitionInfo partition;
ASSERT_EQ(OB_SUCCESS, build_partition(table_id, partition, replica_cnt, pos));
ASSERT_EQ(OB_SUCCESS, list.add_partition(partition));
}
ASSERT_EQ(16, list.pkey_array_.count());
ASSERT_EQ(3, list.ml_pk_array_.count());
ASSERT_EQ(3, list.ml_pk_array_.at(0).member_list_.get_member_number());
// ASSERT_EQ(A, list.ml_pk_array_.at(0).member_list_.at(0));
// ASSERT_EQ(B, list.ml_pk_array_.at(0).member_list_.at(1));
// ASSERT_EQ(C, list.ml_pk_array_.at(0).member_list_.at(2));
CHECK_RESULT(A, 0, 0);
CHECK_RESULT(B, 0, 1);
CHECK_RESULT(C, 0, 2);
ASSERT_EQ(8, list.ml_pk_array_.at(0).pkey_info_.count());
ASSERT_EQ(0, list.ml_pk_array_.at(0).pkey_info_.at(0).pkey_index_);
ASSERT_EQ(1, list.ml_pk_array_.at(0).pkey_info_.at(1).pkey_index_);
ASSERT_EQ(2, list.ml_pk_array_.at(0).pkey_info_.at(2).pkey_index_);
ASSERT_EQ(3, list.ml_pk_array_.at(0).pkey_info_.at(3).pkey_index_);
ASSERT_EQ(12, list.ml_pk_array_.at(0).pkey_info_.at(4).pkey_index_);
ASSERT_EQ(13, list.ml_pk_array_.at(0).pkey_info_.at(5).pkey_index_);
ASSERT_EQ(14, list.ml_pk_array_.at(0).pkey_info_.at(6).pkey_index_);
ASSERT_EQ(15, list.ml_pk_array_.at(0).pkey_info_.at(7).pkey_index_);
ASSERT_EQ(2, list.ml_pk_array_.at(1).member_list_.get_member_number());
CHECK_RESULT(E, 1, 0);
CHECK_RESULT(F, 1, 1);
ASSERT_EQ(4, list.ml_pk_array_.at(1).pkey_info_.count());
ASSERT_EQ(4, list.ml_pk_array_.at(2).member_list_.get_member_number());
// ASSERT_EQ(A, list.ml_pk_array_.at(2).member_list_.at(0));
// ASSERT_EQ(B, list.ml_pk_array_.at(2).member_list_.at(1));
// ASSERT_EQ(C, list.ml_pk_array_.at(2).member_list_.at(2));
// ASSERT_EQ(D, list.ml_pk_array_.at(2).member_list_.at(3));
CHECK_RESULT(A, 2, 0);
CHECK_RESULT(B, 2, 1);
CHECK_RESULT(C, 2, 2);
CHECK_RESULT(D, 2, 3);
ASSERT_EQ(4, list.ml_pk_array_.at(2).pkey_info_.count());
ASSERT_EQ(8, list.ml_pk_array_.at(2).pkey_info_.at(0).pkey_index_);
ASSERT_EQ(9, list.ml_pk_array_.at(2).pkey_info_.at(1).pkey_index_);
ASSERT_EQ(10, list.ml_pk_array_.at(2).pkey_info_.at(2).pkey_index_);
ASSERT_EQ(11, list.ml_pk_array_.at(2).pkey_info_.at(3).pkey_index_);
}
} // namespace rootserver
} // namespace oceanbase
int main(int argc, char** argv)
{
oceanbase::common::ObLogger::get_logger().set_log_level("INFO");
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
Reference in New Issue View Git Blame Copy Permalink