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

380 lines
11 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.
*/
#ifndef OCEANBASE_ROOTSERVER_TEST_FAKE_SERVER_MANAGER_H
#define OCEANBASE_ROOTSERVER_TEST_FAKE_SERVER_MANAGER_H
#include "rootserver/ob_server_manager.h"
#include "lib/container/ob_array_iterator.h"
#include "share/ob_server_status.h"
#include "rootserver/ob_zone_manager.h"
namespace oceanbase {
namespace rootserver {
class FakeServerMgr : public ObServerManager {
public:
FakeServerMgr() : server_id_(0)
{}
~FakeServerMgr()
{}
void fake_init(ObZoneManager* zone_mgr)
{
inited_ = true;
zone_mgr_ = zone_mgr;
}
int add_server(const common::ObAddr& server, const ObZone& zone);
virtual int get_server_statuses(
const common::ObZone& zone, common::ObArray<share::ObServerStatus>& server_statuses) const
{
UNUSED(zone); // always get all zone
return server_statuses.assign(server_statuses_);
}
private:
int64_t server_id_;
ObZoneManager* zone_mgr_;
};
int FakeServerMgr::add_server(const common::ObAddr& server, const ObZone& zone)
{
int ret = common::OB_SUCCESS;
share::ObServerStatus* server_status = NULL;
if (!server.is_valid() || OB_ISNULL(zone_mgr_)) {
ret = OB_INVALID_ARGUMENT;
RS_LOG(WARN, "invalid server", K(server), K(zone_mgr_), K(ret));
} else if (!zone.is_empty()) {
bool zone_active = false;
if (OB_FAIL(zone_mgr_->check_zone_active(zone, zone_active))) {
RS_LOG(WARN, "check_zone_active failed", K(zone), K(ret));
} else if (!zone_active) {
ret = common::OB_ZONE_NOT_ACTIVE;
RS_LOG(WARN, "zone not active", K(zone), K(ret));
}
}
if (OB_SUCC(ret)) {
if (OB_SUCC(find(server, server_status))) {
if (NULL == server_status) {
ret = common::OB_ERR_UNEXPECTED;
RS_LOG(WARN, "server_status is null", K(ret));
} else if (!server_status->is_status_valid()) {
ret = common::OB_ERR_UNEXPECTED;
RS_LOG(WARN, "status not valid", K(ret), "status", *server_status);
} else {
ret = common::OB_ENTRY_EXIST;
RS_LOG(WARN, "server already added", K(server), K(ret));
}
} else if (common::OB_ENTRY_NOT_EXIST != ret) {
RS_LOG(WARN, "find failed", K(server), K(ret));
} else {
ret = common::OB_SUCCESS;
share::ObServerStatus new_server_status;
new_server_status.id_ = server_id_++;
new_server_status.server_ = server;
new_server_status.zone_ = zone;
new_server_status.admin_status_ = share::ObServerStatus::OB_SERVER_ADMIN_NORMAL;
new_server_status.hb_status_ = share::ObServerStatus::OB_HEARTBEAT_ALIVE;
new_server_status.merged_version_ = 2;
if (OB_FAIL(server_statuses_.push_back(new_server_status))) {
RS_LOG(WARN, "push_back failed", K(ret));
}
}
}
RS_LOG(INFO, "add new server", K(server), K(zone), K(ret));
return ret;
}
class FakeServerManager : public ObServerManager {
public:
void set_is_inited(bool is_inited)
{
UNUSED(is_inited);
// inited_ = is_inited;
}
void set(const common::ObZone& zone, const common::ObAddr& addr,
share::ObServerStatus::DisplayStatus stat = share::ObServerStatus::OB_SERVER_ACTIVE)
{
share::ObServerStatus* server = NULL;
FOREACH(s, all_)
{
if (s->server_ == addr) {
server = &(*s);
}
}
if (NULL == server) {
share::ObServerStatus new_server;
new_server.server_ = addr;
all_.push_back(new_server);
server = &all_.at(all_.count() - 1);
}
server->zone_ = zone;
server->admin_status_ = share::ObServerStatus::OB_SERVER_ADMIN_NORMAL;
if (share::ObServerStatus::OB_SERVER_ACTIVE == stat) {
server->hb_status_ = share::ObServerStatus::OB_HEARTBEAT_ALIVE;
server->start_service_time_ = common::ObTimeUtility::current_time();
} else {
server->hb_status_ = share::ObServerStatus::OB_HEARTBEAT_LEASE_EXPIRED;
server->start_service_time_ = 0;
}
if (share::ObServerStatus::OB_SERVER_DELETING == stat) {
server->admin_status_ = share::ObServerStatus::OB_SERVER_ADMIN_DELETING;
}
}
virtual int check_server_alive(const common::ObAddr& server, bool& alive) const
{
int ret = common::OB_SUCCESS;
alive = false;
FOREACH(s, all_)
{
if (s->server_ == server) {
alive = s->is_alive();
break;
}
}
return ret;
}
int set_server_version(const common::ObAddr& server, const char* version)
{
int ret = common::OB_SUCCESS;
FOREACH(s, all_)
{
if (s->server_ == server) {
MEMCPY(s->build_version_, version, common::OB_SERVER_VERSION_LENGTH);
break;
}
}
return ret;
}
int get_min_server_version(char min_server_version[OB_SERVER_VERSION_LENGTH])
{
int ret = OB_SUCCESS;
ObClusterVersion version_parser;
uint64_t cur_min_version = UINT64_MAX;
FOREACH(s, all_)
{
char* saveptr = NULL;
char* version = STRTOK_R(s->build_version_, "_", &saveptr);
if (NULL == version || strlen(version) + 1 > OB_SERVER_VERSION_LENGTH) {
ret = OB_INVALID_ARGUMENT;
RS_LOG(WARN, "invalid build version format", "build_version", s->build_version_);
} else if (OB_FAIL(version_parser.refresh_cluster_version(version))) {
RS_LOG(WARN, "failed to parse version", "version", version);
} else {
if (version_parser.get_cluster_version() < cur_min_version) {
size_t len = strlen(version);
MEMCPY(min_server_version, version, len);
min_server_version[len] = '\0';
cur_min_version = version_parser.get_cluster_version();
}
}
}
return ret;
}
virtual int check_server_active(const common::ObAddr& server, bool& active) const
{
int ret = common::OB_SUCCESS;
active = false;
FOREACH(s, all_)
{
if (s->server_ == server) {
active = s->is_active();
break;
}
}
return ret;
}
virtual int check_in_service(const common::ObAddr& server, bool& in_service) const
{
int ret = common::OB_SUCCESS;
bool exist = false;
in_service = false;
FOREACH(s, all_)
{
if (s->server_ == server) {
in_service = s->in_service();
exist = true;
break;
}
}
if (!exist) {
ret = common::OB_ENTRY_NOT_EXIST;
}
return ret;
}
virtual int check_migrate_in_blocked(const common::ObAddr& server, bool& blocked) const
{
int ret = common::OB_SUCCESS;
bool exist = false;
blocked = false;
FOREACH(s, all_)
{
if (s->server_ == server) {
blocked = s->is_migrate_in_blocked();
exist = true;
break;
}
}
if (!exist) {
ret = common::OB_ENTRY_NOT_EXIST;
}
return ret;
}
virtual int get_server_statuses(
const common::ObZone& zone, common::ObArray<share::ObServerStatus>& server_statuses) const
{
UNUSED(zone); // always get all zone
return server_statuses.assign(all_);
}
int get_servers_of_zone(const common::ObZone& zone, ObServerManager::ObServerArray& server_list) const
{
int ret = common::OB_SUCCESS;
FOREACH_X(s, all_, common::OB_SUCCESS == ret)
{
if (zone.is_empty() || zone == s->zone_) {
if (OB_FAIL(server_list.push_back(s->server_))) {
RS_LOG(WARN, "add server failed", K(ret));
}
}
}
return ret;
}
virtual int get_server_status(const common::ObAddr& server, share::ObServerStatus& server_status)
{
int ret = common::OB_ENTRY_NOT_EXIST;
FOREACH(s, all_)
{
if (s->server_ == server) {
server_status = *s;
ret = common::OB_SUCCESS;
}
}
return ret;
}
int get_alive_servers(const common::ObZone& zone, ObServerManager::ObIServerArray& server_list) const
{
int ret = common::OB_SUCCESS;
FOREACH_X(s, all_, common::OB_SUCCESS == ret)
{
if (!s->is_alive()) {
continue;
}
if (zone.is_empty() || zone == s->zone_) {
if (OB_FAIL(server_list.push_back(s->server_))) {
RS_LOG(WARN, "add server failed", K(ret));
}
}
}
return ret;
}
int get_server_zone(const common::ObAddr& addr, common::ObZone& zone) const
{
int ret = common::OB_ENTRY_NOT_EXIST;
FOREACH(s, all_)
{
if (s->server_ == addr) {
zone = s->zone_;
ret = common::OB_SUCCESS;
}
}
return ret;
}
share::ObServerStatus* get(const common::ObAddr& addr)
{
share::ObServerStatus* stat = NULL;
FOREACH(s, all_)
{
if (s->server_ == addr) {
stat = &(*s);
}
}
return stat;
}
int delete_server(const common::ObAddr& server, const common::ObZone& zone)
{
int ret = common::OB_SUCCESS;
UNUSED(zone);
FOREACH(s, all_)
{
if (s->server_ == server) {
s->admin_status_ = share::ObServerStatus::OB_SERVER_ADMIN_DELETING;
break;
}
}
return ret;
}
int end_delete_server(const common::ObAddr& server, const common::ObZone& zone, const bool commit)
{
int ret = common::OB_SUCCESS;
UNUSED(zone);
int64_t index = -1;
for (int64_t i = 0; i < all_.count(); ++i) {
if (all_.at(i).server_ == server) {
index = i;
}
}
if (-1 != index) {
if (commit) {
if (OB_FAIL(all_.remove(index))) {
RS_LOG(WARN, "remove failed", K(index), K(ret));
}
} else {
all_.at(index).admin_status_ = share::ObServerStatus::OB_SERVER_ADMIN_NORMAL;
}
}
return ret;
}
int set_with_partition(const common::ObAddr& server)
{
UNUSED(server);
return common::OB_SUCCESS;
}
int set_force_stop_hb(const common::ObAddr& server, const bool& force_stop_hb)
{
int ret = common::OB_SUCCESS;
int64_t index = -1;
for (int64_t i = 0; i < all_.count(); ++i) {
if (all_.at(i).server_ == server) {
index = i;
}
}
if (-1 != index) {
if (share::ObServerStatus::OB_SERVER_ADMIN_DELETING == all_.at(index).admin_status_) {
all_.at(index).force_stop_hb_ = force_stop_hb;
}
}
return ret;
}
void set_inited(bool inited)
{
inited_ = inited;
}
public:
common::ObArray<share::ObServerStatus> all_;
};
} // end namespace rootserver
} // end namespace oceanbase
#endif
Reference in New Issue View Git Blame Copy Permalink