init push
This commit is contained in:
oceanbase-admin
523
unittest/clog/mock_partition_service.h
Normal file
523
unittest/clog/mock_partition_service.h
Normal file
@ -0,0 +1,523 @@
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef OCEANBASE_UNITTEST_MOCK_PARTITION_MGR_H_
|
||||
#define OCEANBASE_UNITTEST_MOCK_PARTITION_MGR_H_
|
||||
#include "mock_ob_partition_log_service.h"
|
||||
#include "../storage/mockcontainer/mock_ob_partition.h"
|
||||
#include "../storage/mockcontainer/mock_ob_partition_service.h"
|
||||
|
||||
namespace oceanbase {
|
||||
using namespace clog;
|
||||
namespace storage {
|
||||
class MockObPartition : public storage::MockObIPartition {
|
||||
public:
|
||||
MockObPartition() : valid_(false)
|
||||
{}
|
||||
|
||||
public:
|
||||
int init(int32_t seed)
|
||||
{
|
||||
partition_key_.init(seed, seed, 1024);
|
||||
return common::OB_SUCCESS;
|
||||
}
|
||||
clog::ObIPartitionLogService* get_log_service()
|
||||
{
|
||||
return &mock_pls_;
|
||||
}
|
||||
void set_valid(bool valid)
|
||||
{
|
||||
valid_ = valid;
|
||||
return;
|
||||
}
|
||||
bool is_valid() const
|
||||
{
|
||||
return valid_;
|
||||
}
|
||||
const common::ObPartitionKey& get_partition_key() const
|
||||
{
|
||||
return partition_key_;
|
||||
}
|
||||
virtual int get_safe_publish_version(int64_t& publish_version)
|
||||
{
|
||||
UNUSED(publish_version);
|
||||
return 0;
|
||||
}
|
||||
|
||||
private:
|
||||
clog::MockPartitionLogService mock_pls_;
|
||||
common::ObPartitionKey partition_key_;
|
||||
bool valid_;
|
||||
};
|
||||
|
||||
class MockObPartitionService : public storage::MockObIPartitionService {
|
||||
public:
|
||||
MockObPartitionService() : list_(NULL)
|
||||
{}
|
||||
|
||||
public:
|
||||
struct MockPartitionNode {
|
||||
MockObPartition partition_;
|
||||
MockPartitionNode* next_;
|
||||
MockPartitionNode() : partition_(), next_(NULL)
|
||||
{}
|
||||
~MockPartitionNode()
|
||||
{
|
||||
partition_.destroy();
|
||||
next_ = NULL;
|
||||
}
|
||||
};
|
||||
class MockObPartitionIter : public storage::ObIPartitionIterator {
|
||||
public:
|
||||
MockObPartitionIter() : mgr_(NULL), curr_node_(NULL)
|
||||
{}
|
||||
MockObPartitionIter(ObPartitionService* mgr)
|
||||
: mgr_(reinterpret_cast<MockObPartitionService*>(mgr)), curr_node_(NULL)
|
||||
{}
|
||||
virtual ~MockObPartitionIter()
|
||||
{
|
||||
mgr_ = NULL;
|
||||
curr_node_ = NULL;
|
||||
}
|
||||
int get_next(storage::ObIPartitionGroup*& partition)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
MockPartitionNode* next_node = NULL;
|
||||
if (NULL == mgr_) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
CLOG_LOG(WARN, "mgr is NULL");
|
||||
} else if (OB_SUCCESS != (ret = mgr_->get_next(curr_node_, next_node))) {
|
||||
CLOG_LOG(WARN, "fail to get next node", "ret", ret);
|
||||
} else if (NULL == next_node) {
|
||||
ret = OB_ITER_END;
|
||||
} else {
|
||||
partition = &next_node->partition_;
|
||||
curr_node_ = next_node;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
private:
|
||||
MockObPartitionService* mgr_;
|
||||
MockPartitionNode* curr_node_;
|
||||
};
|
||||
|
||||
public:
|
||||
int create_partition(int32_t seed)
|
||||
// int create_partition(common::ObMemberList &list, const ObPartitionKey &key, const int64_t replica_num)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
MockPartitionNode* node = NULL;
|
||||
if (NULL == (node = static_cast<oceanbase::storage::MockObPartitionService::MockPartitionNode*>(
|
||||
ob_malloc(sizeof(MockPartitionNode), ObModIds::OB_UPS_LOG)))) {
|
||||
ret = OB_ALLOCATE_MEMORY_FAILED;
|
||||
CLOG_LOG(WARN, "alloc MockPartitionNode fail");
|
||||
} else {
|
||||
new (node) MockPartitionNode();
|
||||
node->partition_.init(seed);
|
||||
if (NULL == list_) {
|
||||
list_ = node;
|
||||
} else {
|
||||
node->next_ = list_;
|
||||
list_ = node;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int get_next(MockPartitionNode* curr_node, MockPartitionNode*& next_node)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
if (NULL == curr_node) {
|
||||
next_node = list_;
|
||||
} else {
|
||||
next_node = curr_node->next_;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
ObIPartitionIterator* alloc_scan_iter()
|
||||
{
|
||||
MockObPartitionService::MockObPartitionIter* iter = NULL;
|
||||
if (NULL == (iter = static_cast<oceanbase::storage::MockObPartitionService::MockObPartitionIter*>(
|
||||
ob_malloc(sizeof(MockObPartitionService::MockObPartitionIter), ObModIds::OB_UPS_LOG)))) {
|
||||
CLOG_LOG(WARN, "OB_ALLOCATE_MEMORY_FAILED");
|
||||
} else {
|
||||
new (iter) MockObPartitionService::MockObPartitionIter(this);
|
||||
}
|
||||
return iter;
|
||||
}
|
||||
int revert_scan_iter(ObIPartitionIterator* iter)
|
||||
{
|
||||
ob_free(iter);
|
||||
return common::OB_SUCCESS;
|
||||
}
|
||||
int get_partition(const common::ObPartitionKey& pkey, storage::ObIPartitionGroup*& partition)
|
||||
{
|
||||
int ret = OB_ENTRY_NOT_EXIST;
|
||||
MockPartitionNode* curr_node = list_;
|
||||
while (NULL != curr_node) {
|
||||
if (curr_node->partition_.get_partition_key() == pkey) {
|
||||
ret = OB_SUCCESS;
|
||||
partition = &curr_node->partition_;
|
||||
break;
|
||||
}
|
||||
curr_node = curr_node->next_;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
private:
|
||||
MockPartitionNode* list_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(MockObPartitionService);
|
||||
};
|
||||
|
||||
/*class MockPartition: public ObIPartition
|
||||
{
|
||||
public:
|
||||
int init(int64_t seed)
|
||||
{
|
||||
seed_ = seed;
|
||||
log_cursor_.file_id_ = seed;
|
||||
log_cursor_.offset_ = static_cast<int32_t>(seed);
|
||||
partition_key_.init(seed, seed);
|
||||
append_log_count_ = 0;
|
||||
return common::OB_SUCCESS;
|
||||
}
|
||||
//virtual int get_log_cursor(ObLogCursor &cursor)
|
||||
//{
|
||||
// cursor.deep_copy(log_cursor_);
|
||||
// return common::OB_SUCCESS;
|
||||
//}
|
||||
virtual const common::ObPartitionKey &get_partition_key() const
|
||||
{
|
||||
return partition_key_;
|
||||
}
|
||||
virtual int append_disk_log(const ObLogEntry &log_entry, const ObLogCursor &log_cursor)
|
||||
{
|
||||
UNUSED(log_entry);
|
||||
UNUSED(log_cursor);
|
||||
int ret = common::OB_SUCCESS;
|
||||
if (append_log_count_ <= 100) {
|
||||
ret = common::OB_ERROR_OUT_OF_RANGE;
|
||||
++append_log_count_;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
virtual int switch_log() {return common::OB_SUCCESS;}
|
||||
virtual int set_scan_disk_log_finished()
|
||||
{
|
||||
int ret = common::OB_SUCCESS;
|
||||
return ret;
|
||||
}
|
||||
virtual int switch_state()
|
||||
{
|
||||
int ret = common::OB_SUCCESS;
|
||||
if (seed_ % 3 == 1) {
|
||||
ret = common::OB_ERROR;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
virtual bool check_mc_timeout()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
virtual int check_stale_member(common::ObServer &server)
|
||||
{
|
||||
UNUSED(server);
|
||||
int ret = common::OB_SUCCESS;
|
||||
if (seed_ % 3 == 0) {
|
||||
ret = common::OB_NOT_MASTER;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
virtual int remove_member(const common::ObServer &server)
|
||||
{
|
||||
UNUSED(server);
|
||||
return common::OB_SUCCESS;
|
||||
}
|
||||
|
||||
virtual uint64_t get_curr_file_min_log_id()
|
||||
{
|
||||
uint64_t ret = common::OB_INVALID_ID;
|
||||
if (seed_ != 2) {
|
||||
ret = static_cast<uint64_t>(seed_);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
virtual uint64_t get_curr_file_max_log_id()
|
||||
{
|
||||
uint64_t ret = common::OB_INVALID_ID;
|
||||
if (seed_ != 2) {
|
||||
ret = static_cast<uint64_t>(seed_) * 2;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
virtual bool is_valid() const
|
||||
{
|
||||
bool bool_ret = true;
|
||||
if (4 == seed_) {
|
||||
bool_ret = false;
|
||||
}
|
||||
return bool_ret;
|
||||
}
|
||||
|
||||
virtual ObIPartitionLogService *get_log_service()
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
virtual int flush_cb(const ObLogType type,
|
||||
const uint64_t log_id,
|
||||
const int64_t mc_timestamp,
|
||||
const int64_t proposal_id,
|
||||
const ObLogCursor &log_cursor)
|
||||
{
|
||||
UNUSED(type);
|
||||
UNUSED(log_id);
|
||||
UNUSED(mc_timestamp);
|
||||
UNUSED(proposal_id);
|
||||
UNUSED(log_cursor);
|
||||
return common::OB_SUCCESS;
|
||||
}
|
||||
|
||||
private:
|
||||
int64_t seed_;
|
||||
int64_t append_log_count_;
|
||||
ObLogCursor log_cursor_;
|
||||
common::ObPartitionKey partition_key_;
|
||||
};
|
||||
|
||||
class MockPartitionIter: public ObIPartitionIter
|
||||
{
|
||||
public:
|
||||
MockPartitionIter(ObIPartitionMgr *partition_mgr): ObIPartitionIter(partition_mgr), num_(0)
|
||||
{
|
||||
partition1.init(1);
|
||||
partition2.init(2);
|
||||
partition3.init(3);
|
||||
partition4.init(4);
|
||||
}
|
||||
virtual int get_next(ObIPartitionGroup *&partition)
|
||||
{
|
||||
int ret = common::OB_SUCCESS;
|
||||
if (num_ == 0) {
|
||||
partition = &partition2;
|
||||
num_ ++;
|
||||
} else if (num_ == 1) {
|
||||
partition = &partition1;
|
||||
num_ ++;
|
||||
} else if (num_ == 2) {
|
||||
partition = &partition3;
|
||||
num_ ++;
|
||||
} else if (num_ == 3) {
|
||||
partition = &partition4;
|
||||
num_ ++;
|
||||
} else {
|
||||
ret = common::OB_ITER_END;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
private:
|
||||
int num_;
|
||||
MockPartition partition1;
|
||||
MockPartition partition2;
|
||||
MockPartition partition3;
|
||||
MockPartition partition4;
|
||||
};
|
||||
|
||||
class MockMorePartitionIter: public ObIPartitionIter
|
||||
{
|
||||
public:
|
||||
MockMorePartitionIter(ObIPartitionMgr *partition_mgr) : ObIPartitionIter(partition_mgr), num_(0)
|
||||
{
|
||||
for (int64_t i = 0; i < PARTITION_COUNT; ++i) {
|
||||
partitions[i].init(i);
|
||||
}
|
||||
}
|
||||
virtual int get_next(ObIPartitionGroup *&partition)
|
||||
{
|
||||
int ret = common::OB_SUCCESS;
|
||||
if (num_ < PARTITION_COUNT) {
|
||||
partition = &partitions[num_];
|
||||
num_++;
|
||||
} else {
|
||||
ret = common::OB_ITER_END;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
private:
|
||||
static const int PARTITION_COUNT = 20;
|
||||
int num_;
|
||||
MockPartition partitions[PARTITION_COUNT];
|
||||
};
|
||||
|
||||
class MockNullPartitionIter: public MockPartitionIter
|
||||
{
|
||||
public:
|
||||
MockNullPartitionIter(ObIPartitionMgr *partition_mgr): MockPartitionIter(partition_mgr)
|
||||
{
|
||||
}
|
||||
public:
|
||||
virtual int get_next(ObIPartitionGroup **partition)
|
||||
{
|
||||
*partition = NULL;
|
||||
return common::OB_SUCCESS;
|
||||
}
|
||||
};
|
||||
|
||||
class MockPartitionMgr: public ObIPartitionMgr
|
||||
{
|
||||
public:
|
||||
MockPartitionMgr()
|
||||
{
|
||||
partition1.init(1);
|
||||
partition2.init(2);
|
||||
partition3.init(3);
|
||||
partition3.init(4);
|
||||
}
|
||||
public:
|
||||
virtual int get_partition(const common::ObPartitionKey &partition_key,
|
||||
ObIPartitionGroup *&partition)
|
||||
{
|
||||
int ret = common::OB_SUCCESS;
|
||||
if (partition_key.table_id_ == 1) {
|
||||
partition = &partition1;
|
||||
} else if (partition_key.table_id_ == 2) {
|
||||
partition = &partition2;
|
||||
} else if (partition_key.table_id_ == 3) {
|
||||
partition = &partition3;
|
||||
} else if (partition_key.table_id_ == 4) {
|
||||
partition = &partition4;
|
||||
} else {
|
||||
ret = common::OB_ENTRY_NOT_EXIST;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
virtual void revert(ObIPartitionGroup *partition)
|
||||
{
|
||||
UNUSED(partition);
|
||||
}
|
||||
virtual ObIPartitionIter *alloc_scan_iter()
|
||||
{
|
||||
ObIPartitionIter *partition_iter = new MockPartitionIter(this);
|
||||
return partition_iter;
|
||||
}
|
||||
virtual int revert_scan_iter(ObIPartitionIter *iter)
|
||||
{
|
||||
delete iter;
|
||||
return common::OB_SUCCESS;
|
||||
}
|
||||
private:
|
||||
MockPartition partition1;
|
||||
MockPartition partition2;
|
||||
MockPartition partition3;
|
||||
MockPartition partition4;
|
||||
};
|
||||
|
||||
class MockMorePartitionMgr: public ObIPartitionMgr
|
||||
{
|
||||
public:
|
||||
MockMorePartitionMgr()
|
||||
{
|
||||
}
|
||||
public:
|
||||
virtual int get_partition(const uint64_t table_id,
|
||||
const int64_t partition_idx,
|
||||
ObIPartitionGroup **partition)
|
||||
{
|
||||
UNUSED(table_id);
|
||||
UNUSED(partition_idx);
|
||||
UNUSED(partition);
|
||||
return common::OB_SUCCESS;
|
||||
}
|
||||
virtual void revert(const ObIPartitionGroup *partition)
|
||||
{
|
||||
UNUSED(partition);
|
||||
}
|
||||
virtual ObIPartitionIter *alloc_scan_iter()
|
||||
{
|
||||
ObIPartitionIter *partition_iter = new MockMorePartitionIter(this);
|
||||
return partition_iter;
|
||||
}
|
||||
virtual int revert_scan_iter(ObIPartitionIter *iter)
|
||||
{
|
||||
delete iter;
|
||||
return common::OB_SUCCESS;
|
||||
}
|
||||
};
|
||||
|
||||
class MockNullPartitionMgr: public MockPartitionMgr
|
||||
{
|
||||
public:
|
||||
virtual ObIPartitionIter *alloc_scan_iter()
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
};
|
||||
|
||||
class MockNull2PartitionMgr: public MockPartitionMgr
|
||||
{
|
||||
public:
|
||||
virtual ObIPartitionIter *alloc_scan_iter()
|
||||
{
|
||||
return new MockNullPartitionIter(this);
|
||||
}
|
||||
};
|
||||
|
||||
class MockNull3PartitionMgr: public MockPartitionMgr
|
||||
{
|
||||
public:
|
||||
MockNull3PartitionMgr(): count_(0)
|
||||
{
|
||||
}
|
||||
public:
|
||||
virtual ObIPartitionIter *alloc_scan_iter()
|
||||
{
|
||||
if (0 == count_) {
|
||||
++count_;
|
||||
return new MockPartitionIter(this);
|
||||
} else {
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
private:
|
||||
int64_t count_;
|
||||
};
|
||||
|
||||
class MockNull4PartitionMgr: public MockPartitionMgr
|
||||
{
|
||||
public:
|
||||
MockNull4PartitionMgr(): count_(0)
|
||||
{
|
||||
}
|
||||
public:
|
||||
virtual ObIPartitionIter *alloc_scan_iter()
|
||||
{
|
||||
if (0 == count_) {
|
||||
++count_;
|
||||
return new MockPartitionIter(this);
|
||||
} else {
|
||||
return new MockNullPartitionIter(this);
|
||||
}
|
||||
}
|
||||
private:
|
||||
int64_t count_;
|
||||
};*/
|
||||
} // namespace storage
|
||||
} // namespace oceanbase
|
||||
|
||||
#endif // OCEANBASE_UNITTEST_MOCK_PARTITION_MGR_H_
|
||||
Reference in New Issue
Block a user