hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
9865419f3595a08b52710e517c675d15ab4d748c
oceanbase/unittest/rootserver/test_server_manager.cpp
hnwyllmm 39cc0a6d60 merge devleop into master 20231212
2024-02-08 01:29:33 +00:00

828 lines
33 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>
#define private public
#define protected public
#include "../share/schema/db_initializer.h"
#include "lib/stat/ob_session_stat.h"
#include "share/cache/ob_kv_storecache.h"
#include "rootserver/ob_server_manager.h"
#include "rootserver/ob_unit_manager.h"
#include "rootserver/ob_zone_manager.h"
#include "rootserver/ob_leader_coordinator.h"
#include "share/config/ob_server_config.h"
#include "share/ob_lease_struct.h"
#include "share/ob_rpc_struct.h"
#include "../share/partition_table/fake_part_property_getter.h"
#include "share/ob_tenant_mgr.h"
#undef private
#undef protected
#include "rpc/mock_ob_srv_rpc_proxy.h"
#include "mock_freeze_info_manager.h"
namespace oceanbase
{
using namespace common;
using namespace share;
using namespace share::schema;
using namespace obrpc;
using namespace host;
namespace rootserver
{
class ObFakeServerChangeCB : public ObIServerChangeCallback
{
public:
ObFakeServerChangeCB() {}
virtual ~ObFakeServerChangeCB() {}
virtual int on_server_change()
{
return OB_SUCCESS;
}
};
class ObFakeCB : public ObIStatusChangeCallback
{
public:
ObFakeCB() : return_success_(true) {}
int wakeup_balancer() { return OB_SUCCESS; }
int wakeup_daily_merger() { return OB_SUCCESS; }
int on_server_status_change(const common::ObAddr &server);
int on_start_server(const common::ObAddr &server) {UNUSED(server); return OB_SUCCESS;}
int on_stop_server(const common::ObAddr &server) {UNUSED(server); return OB_SUCCESS;}
void set_return_success(const bool return_success) { return_success_ = return_success; }
private:
bool return_success_;
};
int ObFakeCB::on_server_status_change(const common::ObAddr &server)
{
UNUSED(server);
int ret = OB_SUCCESS;
if (return_success_) {
ret = OB_SUCCESS;
} else {
ret = OB_ERROR;
}
return ret;
}
class FakeZoneManager : public ObZoneManager
{
public:
FakeZoneManager() {}
virtual ~FakeZoneManager() {}
virtual int check_zone_active(const common::ObZone &zone, bool &zone_active) const
{
zone_active = (zone == "1" || zone == "2");
return OB_SUCCESS;
}
};
class FakeUnitManager : public ObUnitManager
{
public:
FakeUnitManager(ObServerManager &server_mgr, ObZoneManager &zone_mgr)
: ObUnitManager(server_mgr, zone_mgr)
{
}
virtual ~FakeUnitManager() {}
virtual int migrate_out_units(const ObAddr &server, const ObIArray<ObAddr> &, bool &empty)
{
ObAddr inner_server;
inner_server.set_ip_addr("127.0.0.1", 9999);
if (server == inner_server) {
empty = false;
} else {
empty = true;
}
return OB_SUCCESS;
}
virtual int cancel_migrate_out_units(const common::ObAddr &server)
{
UNUSED(server);
return OB_SUCCESS;
}
virtual int check_server_empty(const common::ObAddr &server, bool &empty) const
{
ObAddr inner_server;
inner_server.set_ip_addr("127.0.0.1", 9999);
if (server == inner_server) {
empty = true;
} else {
empty = false;
}
return OB_SUCCESS;
}
};
class FakeLeaderCoordinator : public ObLeaderCoordinator
{
public:
virtual void signal();
};
void FakeLeaderCoordinator::signal()
{
//do nothing
}
ObServerConfig &config_ = ObServerConfig::get_instance();
class TestServerManager : public ::testing::Test
{
public:
TestServerManager();
virtual ~TestServerManager();
virtual void SetUp();
virtual void TearDown();
protected:
ObFakeCB cb_;
ObFakeServerChangeCB cb2_;
MockObSrvRpcProxy rpc_proxy_;
MockFreezeInfoManager freeze_info_manager_;
ObServerManager server_manager_;
FakeZoneManager zone_mgr_;
FakeUnitManager unit_mgr_;
FakeLeaderCoordinator leader_coordinator_;
DBInitializer db_initer_;
uint64_t server_id_;
void build_status(ObServerStatus::DisplayStatus status, const int64_t now,
const ObZone &zone, const ObAddr &server,
ObServerStatus &server_status);
};
TestServerManager::TestServerManager()
: cb_(), cb2_(), server_manager_(), zone_mgr_(), unit_mgr_(server_manager_, zone_mgr_),
server_id_(OB_INIT_SERVER_ID)
{
}
TestServerManager::~TestServerManager()
{
}
template <typename T>
ObArray<T> to_array(const T &t) { ObArray<T> res; res.push_back(t); return res; }
void TestServerManager::TearDown()
{
ObKVGlobalCache::get_instance().destroy();
}
void TestServerManager::SetUp()
{
ASSERT_EQ(OB_SUCCESS, db_initer_.init());
ObKVGlobalCache::get_instance().init();
ASSERT_EQ(OB_SUCCESS, db_initer_.create_system_table(false));
ASSERT_EQ(OB_SUCCESS, db_initer_.fill_sys_stat_table(OB_SYS_TENANT_ID));
const int64_t now = ::oceanbase::common::ObTimeUtility::current_time();
ObAddr rs_addr = F;
ASSERT_EQ(OB_SUCCESS, server_manager_.init(cb_, cb2_, db_initer_.get_sql_proxy(), unit_mgr_,
zone_mgr_, leader_coordinator_, config_, rs_addr,
rpc_proxy_));
server_manager_.reset();
ObServerManager::ObServerStatusArray server_statuses;
ObServerStatus server_status;
ObAddr server;
// offline server status
server_status.reset();
server = A;
build_status(ObServerStatus::OB_SERVER_INACTIVE, now, "1", server, server_status);
ASSERT_EQ(OB_SUCCESS, server_statuses.push_back(server_status));
// serving server status
server_status.reset();
server = B;
build_status(ObServerStatus::OB_SERVER_ACTIVE, now, "1", server, server_status);
ASSERT_EQ(OB_SUCCESS, server_statuses.push_back(server_status));
// delete server status
server_status.reset();
server = C;
build_status(ObServerStatus::OB_SERVER_DELETING, now, "1", server, server_status);
ASSERT_EQ(OB_SUCCESS, server_statuses.push_back(server_status));
ASSERT_EQ(OB_SUCCESS, server_manager_.load_server_statuses(server_statuses));
ASSERT_EQ(true, server_manager_.has_build());
// ObServerManager::load_server_status() will set heartbeat status to lease_expired if alive,
// set B to alive manually.
server = B;
ObServerStatus ss;
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(server, ss));
ss.hb_status_ = ObServerStatus::OB_HEARTBEAT_ALIVE;
ASSERT_EQ(OB_SUCCESS, server_manager_.update_server_status(ss));
}
void TestServerManager::build_status(ObServerStatus::DisplayStatus status, const int64_t now,
const ObZone &zone, const ObAddr &server,
ObServerStatus &server_status)
{
if (ObServerStatus::OB_SERVER_INACTIVE == status) {
// lease outdate 4s
server_status.last_hb_time_ = now - config_.lease_time - 4000000;
server_status.admin_status_ = ObServerStatus::OB_SERVER_ADMIN_NORMAL;
server_status.hb_status_ = ObServerStatus::OB_HEARTBEAT_LEASE_EXPIRED;
} else if (ObServerStatus::OB_SERVER_ACTIVE == status) {
// 1s
server_status.last_hb_time_ = now - 1000000;
server_status.admin_status_ = ObServerStatus::OB_SERVER_ADMIN_NORMAL;
server_status.hb_status_ = ObServerStatus::OB_HEARTBEAT_ALIVE;
} else if (ObServerStatus::OB_SERVER_DELETING == status) {
server_status.last_hb_time_ = 0;
server_status.admin_status_ = ObServerStatus::OB_SERVER_ADMIN_DELETING;
server_status.hb_status_ = ObServerStatus::OB_HEARTBEAT_LEASE_EXPIRED;
}
ASSERT_TRUE(strlen("dev1.0") == snprintf(server_status.build_version_, OB_SERVER_VERSION_LENGTH,
"%s", "dev1.0"));
server_status.zone_ = zone;
server_status.server_ = server;
server_status.id_ = server_id_;
++server_id_;
}
TEST_F(TestServerManager, basic)
{
ObServerManager server_mgr;
ObServerInfoList server_info_list;
uint64_t server_id = OB_INVALID_ID;
bool to_alive = false;
bool update_delay_time_flag = false;
ASSERT_EQ(OB_NOT_INIT, server_mgr.add_server_list(server_info_list, server_id));
ObLeaseRequest lq;
ASSERT_EQ(OB_NOT_INIT, server_mgr.receive_hb(lq, server_id, to_alive, update_delay_time_flag));
ObAddr server;
server = B;
bool is_alive = false;
ASSERT_EQ(OB_NOT_INIT, server_mgr.check_server_alive(server, is_alive));
ObZone zone;
int64_t count = 0;
ObServerManager::ObServerArray servers;
ASSERT_EQ(OB_NOT_INIT, server_mgr.get_alive_servers(zone, servers));
ASSERT_EQ(OB_NOT_INIT, server_mgr.get_alive_server_count(zone, count));
ASSERT_EQ(OB_NOT_INIT, server_mgr.get_servers_of_zone(zone, servers));
ASSERT_EQ(OB_NOT_INIT, server_mgr.check_servers());
ObServerStatus status;
ASSERT_EQ(OB_NOT_INIT, server_mgr.get_server_status(server, status));
ASSERT_EQ(OB_NOT_INIT, server_mgr.update_server_status(status));
ObServerManager::ObServerStatusArray statuses;
ASSERT_EQ(OB_NOT_INIT, server_mgr.load_server_statuses(statuses));
ASSERT_EQ(OB_NOT_INIT, server_mgr.get_server_statuses(zone, statuses));
ASSERT_EQ(OB_NOT_INIT, server_mgr.get_server_zone(server, zone));
ASSERT_EQ(OB_NOT_INIT, server_mgr.add_server(server, zone));
ASSERT_EQ(OB_NOT_INIT, server_mgr.delete_server(to_array(server), zone));
ASSERT_EQ(OB_NOT_INIT, server_mgr.end_delete_server(server, zone, true));
ASSERT_EQ(OB_NOT_INIT, server_mgr.start_server(server, zone));
ASSERT_EQ(OB_NOT_INIT, server_mgr.stop_server(server, zone));
server_mgr.reset();
LOG_INFO("server manager", K(server_mgr));
}
#define GET_STR(fun, ...) ({ const char *__str = NULL; ret = fun(__VA_ARGS__, __str); __str;})
#define GET_STATUS(fun, ...) ({ ObServerStatus::DisplayStatus __s; ret = fun(__VA_ARGS__, __s); __s; })
TEST_F(TestServerManager, server_status_func)
{
ObServerStatus server_status;
server_status.hb_status_ = ObServerStatus::OB_HEARTBEAT_LEASE_EXPIRED;
server_status.admin_status_ = ObServerStatus::OB_SERVER_ADMIN_NORMAL;
int ret = OB_SUCCESS;
ASSERT_STREQ("inactive", GET_STR(ObServerStatus::display_status_str, server_status.get_display_status()));
ASSERT_EQ(server_status.get_display_status(), GET_STATUS(ObServerStatus::str2display_status, "inactive"));
server_status.hb_status_ = ObServerStatus::OB_HEARTBEAT_ALIVE;
ASSERT_STREQ("active", GET_STR(ObServerStatus::display_status_str, server_status.get_display_status()));
ASSERT_EQ(server_status.get_display_status(), GET_STATUS(ObServerStatus::str2display_status, "active"));
server_status.admin_status_ = ObServerStatus::OB_SERVER_ADMIN_DELETING;
ASSERT_STREQ("deleting", GET_STR(ObServerStatus::display_status_str, server_status.get_display_status()));
ASSERT_EQ(server_status.get_display_status(), GET_STATUS(ObServerStatus::str2display_status, "deleting"));
ASSERT_STREQ(NULL, GET_STR(ObServerStatus::display_status_str, ObServerStatus::OB_DISPLAY_MAX));
ASSERT_NE(OB_SUCCESS, ret);
ASSERT_EQ(ObServerStatus::OB_DISPLAY_MAX, GET_STATUS(ObServerStatus::str2display_status, "randomxxx"));
ASSERT_NE(OB_SUCCESS, ret);
ASSERT_FALSE(server_status.is_valid());
server_status.server_ = B;
server_status.hb_status_ = ObServerStatus::OB_HEARTBEAT_MAX;
ASSERT_FALSE(server_status.is_valid());
server_status.hb_status_ = ObServerStatus::OB_HEARTBEAT_ALIVE;
ASSERT_FALSE(server_status.is_valid());
server_status.id_ = OB_INIT_SERVER_ID;
ASSERT_TRUE(server_status.is_valid());
}
TEST_F(TestServerManager, receive_hb)
{
int64_t alive_count = 0;
bool is_alive = false;
bool to_alive = false;
bool update_delay_time_flag = false;
ObServerManager::ObServerArray server_list;
ASSERT_EQ(OB_SUCCESS, server_manager_.get_alive_servers("1", server_list));
ASSERT_EQ(1, server_list.count());
ASSERT_EQ(OB_SUCCESS, server_manager_.get_alive_server_count("1", alive_count));
ASSERT_EQ(1, alive_count);
ObLeaseRequest lq;
uint64_t server_id = OB_INVALID_ID;
// receive hb of not exist server
lq.server_ = A1;
lq.zone_ = "1";
lq.inner_port_ = 3306;
lq.resource_info_.cpu_ = 1;
lq.resource_info_.mem_in_use_ = 0;
lq.resource_info_.mem_total_ = 1024;
lq.resource_info_.disk_in_use_ = 0;
lq.resource_info_.disk_total_ = 1024;
ASSERT_TRUE(strlen("dev1.0") == snprintf(lq.build_version_, OB_SERVER_VERSION_LENGTH,
"%s", "dev1.0"));
ASSERT_EQ(OB_SUCCESS, server_manager_.check_server_alive(lq.server_, is_alive));
ASSERT_FALSE(is_alive);
ASSERT_EQ(OB_SERVER_NOT_IN_WHITE_LIST, server_manager_.receive_hb(lq, server_id, to_alive, update_delay_time_flag));
ASSERT_EQ(OB_SUCCESS, server_manager_.check_server_alive(lq.server_, is_alive));
ASSERT_FALSE(is_alive);
// receive hb of non exist server
lq.server_ = D;
ASSERT_EQ(OB_SUCCESS, server_manager_.check_server_alive(lq.server_, is_alive));
ASSERT_FALSE(is_alive);
ASSERT_EQ(OB_SERVER_NOT_IN_WHITE_LIST, server_manager_.receive_hb(lq, server_id, to_alive, update_delay_time_flag));
ASSERT_EQ(OB_SUCCESS, server_manager_.check_server_alive(lq.server_, is_alive));
ASSERT_FALSE(is_alive);
// receive hb of offline server
lq.server_ = A;
ASSERT_EQ(OB_SUCCESS, server_manager_.check_server_alive(lq.server_, is_alive));
ASSERT_FALSE(is_alive);
ASSERT_EQ(OB_SUCCESS, server_manager_.receive_hb(lq, server_id, to_alive, update_delay_time_flag));
ASSERT_EQ(OB_SUCCESS, server_manager_.check_server_alive(lq.server_, is_alive));
ASSERT_TRUE(is_alive);
// receive hb of serving server
lq.server_ = B;
ASSERT_EQ(OB_SUCCESS, server_manager_.check_server_alive(lq.server_, is_alive));
ASSERT_TRUE(is_alive);
ASSERT_EQ(OB_SUCCESS, server_manager_.receive_hb(lq, server_id, to_alive, update_delay_time_flag));
ASSERT_EQ(OB_SUCCESS, server_manager_.check_server_alive(lq.server_, is_alive));
ASSERT_TRUE(is_alive);
// receive hb of serving but svn version change server
ASSERT_TRUE(strlen("dev1.111") == snprintf(lq.build_version_, OB_SERVER_VERSION_LENGTH,
"%s", "dev1.111"));
lq.server_ = B;
ASSERT_EQ(OB_SUCCESS, server_manager_.receive_hb(lq, server_id, to_alive, update_delay_time_flag));
ASSERT_EQ(OB_SUCCESS, server_manager_.check_server_alive(lq.server_, is_alive));
ASSERT_TRUE(is_alive);
ASSERT_EQ(OB_SUCCESS, server_manager_.get_alive_servers("1", server_list));
ASSERT_EQ(2, server_list.count());
ASSERT_EQ(OB_SUCCESS, server_manager_.get_alive_server_count("1", alive_count));
ASSERT_EQ(2, alive_count);
// rs change, so rs_addr change, server with root_server change from false to true
MockObSrvRpcProxy rpc_proxy;
MockFreezeInfoManager freeze_info_manager;
ObServerManager temp_server_manager;
ASSERT_EQ(OB_SUCCESS, temp_server_manager.init(cb_, cb2_, db_initer_.get_sql_proxy(), unit_mgr_,
zone_mgr_, leader_coordinator_, config_, lq.server_,
rpc_proxy));
ObArray<ObServerStatus> statuses;
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_statuses(ObZone(""), statuses));
ASSERT_EQ(OB_SUCCESS, temp_server_manager.load_server_statuses(statuses));
ASSERT_EQ(OB_SUCCESS, temp_server_manager.receive_hb(lq, server_id, to_alive, update_delay_time_flag));
ASSERT_EQ(OB_SUCCESS, temp_server_manager.check_server_alive(lq.server_, is_alive));
ASSERT_TRUE(is_alive);
ObServerStatus status;
ASSERT_EQ(OB_SUCCESS, temp_server_manager.get_server_status(lq.server_, status));
ASSERT_TRUE(status.with_rootserver_);
}
TEST_F(TestServerManager, get_set_server_status)
{
ObServerStatus server_status;
ObAddr server;
server = B;
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(server, server_status));
ASSERT_TRUE(server_status.is_active());
server_status.hb_status_ = ObServerStatus::OB_HEARTBEAT_LEASE_EXPIRED;
ASSERT_EQ(OB_SUCCESS, server_manager_.update_server_status(server_status));
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(server, server_status));
ASSERT_FALSE(server_status.is_active());
// not exist server status
server = E;
ASSERT_EQ(OB_ENTRY_NOT_EXIST, server_manager_.get_server_status(server, server_status));
server_status.server_ = server;
ASSERT_EQ(OB_ENTRY_NOT_EXIST, server_manager_.update_server_status(server_status));
}
TEST_F(TestServerManager, check_servers)
{
ObServerStatus server_status;
const int64_t now = ::oceanbase::common::ObTimeUtility::current_time();
ObAddr server;
server = A;
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(server, server_status));
server_status.last_hb_time_ = now;
ASSERT_EQ(OB_SUCCESS, server_manager_.update_server_status(server_status));
server = B;
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(server, server_status));
server_status.last_hb_time_ = now - config_.lease_time - 4000000L;
ASSERT_EQ(OB_SUCCESS, server_manager_.update_server_status(server_status));
ASSERT_EQ(OB_SUCCESS, server_manager_.check_servers());
server = B;
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(server, server_status));
ASSERT_FALSE(server_status.is_alive());
// block migrate in time
server = A;
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(server, server_status));
server_status.block_migrate_in_time_ = now - config_.migration_disable_time- 1;
ASSERT_EQ(OB_SUCCESS, server_manager_.update_server_status(server_status));
bool migrate_in_blocked = false;
ASSERT_EQ(OB_SUCCESS, server_manager_.check_migrate_in_blocked(server, migrate_in_blocked));
ASSERT_TRUE(migrate_in_blocked);
ASSERT_EQ(OB_SUCCESS, server_manager_.check_servers());
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(server, server_status));
ASSERT_EQ(0, server_status.block_migrate_in_time_);
ASSERT_EQ(OB_SUCCESS, server_manager_.check_migrate_in_blocked(server, migrate_in_blocked));
ASSERT_FALSE(migrate_in_blocked);
}
TEST_F(TestServerManager, load_server_statuses)
{
ObServerManager::ObServerStatusArray server_statuses;
// server already exist, will not add to server manager,
// server manager has newer server status
ObServerStatus server_status;
ObAddr server;
const int64_t now = ::oceanbase::common::ObTimeUtility::current_time();
server_status.reset();
server = A;
build_status(ObServerStatus::OB_SERVER_DELETING, now, "1", server, server_status);
ASSERT_EQ(OB_SUCCESS, server_statuses.push_back(server_status));
ASSERT_EQ(OB_SUCCESS, server_manager_.load_server_statuses(server_statuses));
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_statuses("", server_statuses));
ASSERT_EQ(1, server_statuses.count());
ASSERT_EQ(ObServerStatus::OB_SERVER_ADMIN_DELETING, server_statuses.at(0).admin_status_);
}
TEST_F(TestServerManager, get)
{
ObServerManager::ObServerStatusArray server_statuses;
// add a server of other zone
ObLeaseRequest lq;
uint64_t server_id = OB_INVALID_ID;
bool to_alive = false;
bool update_delay_time_flag = false;
lq.server_ = A1;
lq.zone_ = "2";
ASSERT_TRUE(strlen("dev1.0") == snprintf(lq.build_version_, OB_SERVER_VERSION_LENGTH,
"%s", "dev1.0"));
obrpc::ObServerInfo server_info;
server_info.server_ = lq.server_;
server_info.zone_ = lq.zone_;
lq.inner_port_ = 3306;
lq.resource_info_.cpu_ = 1;
lq.resource_info_.mem_in_use_ = 0;
lq.resource_info_.mem_total_ = 1024;
lq.resource_info_.disk_in_use_ = 0;
lq.resource_info_.disk_total_ = 1024;
ObSArray<obrpc::ObServerInfo> server_infos;
ASSERT_EQ(OB_SUCCESS, server_infos.push_back(server_info));
ASSERT_EQ(OB_SUCCESS, server_manager_.add_server_list(server_infos, server_id));
ASSERT_EQ(OB_SUCCESS, server_manager_.receive_hb(lq, server_id, to_alive, update_delay_time_flag));
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_statuses("1", server_statuses));
ASSERT_EQ(3, server_statuses.count());
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_statuses("2", server_statuses));
ASSERT_EQ(1, server_statuses.count());
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_statuses("", server_statuses));
ASSERT_EQ(4, server_statuses.count());
ObServerManager::ObServerArray servers;
ASSERT_EQ(OB_SUCCESS, server_manager_.get_servers_of_zone("1", servers));
ASSERT_EQ(3, servers.count());
ASSERT_EQ(OB_SUCCESS, server_manager_.get_servers_of_zone("2", servers));
ASSERT_EQ(1, servers.count());
ASSERT_EQ(OB_SUCCESS, server_manager_.get_servers_of_zone("", servers));
ASSERT_EQ(4, servers.count());
ObZone zone;
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_zone(lq.server_, zone));
ASSERT_EQ(ObZone("2"), zone);
LOG_INFO("Print", K(server_manager_));
int64_t lease_time = 0;
ASSERT_EQ(OB_SUCCESS, server_manager_.get_lease_duration(lease_time));
ASSERT_EQ(lease_time, db_initer_.get_config().lease_time);
}
TEST_F(TestServerManager, commit_error)
{
bool is_alive = false;
cb_.set_return_success(false);
// if commit_task failed, server manager and __all_server will be not consistent
ObLeaseRequest lq;
uint64_t server_id = OB_INVALID_ID;
bool to_alive = false;
bool update_delay_time_flag = false;
lq.server_ = A1;
lq.zone_ = "1";
lq.inner_port_ = 3306;
lq.resource_info_.cpu_ = 1;
lq.resource_info_.mem_in_use_ = 0;
lq.resource_info_.mem_total_ = 1024;
lq.resource_info_.disk_in_use_ = 0;
lq.resource_info_.disk_total_ = 1024;
ASSERT_TRUE(strlen("dev1.0") == snprintf(lq.build_version_, OB_SERVER_VERSION_LENGTH,
"%s", "dev1.0"));
ASSERT_EQ(OB_SUCCESS, server_manager_.check_server_alive(lq.server_, is_alive));
ASSERT_FALSE(is_alive);
obrpc::ObServerInfo server_info;
server_info.server_ = lq.server_;
server_info.zone_ = lq.zone_;
ObSArray<obrpc::ObServerInfo> server_infos;
ASSERT_EQ(OB_SUCCESS, server_infos.push_back(server_info));
ASSERT_EQ(OB_SUCCESS, server_manager_.add_server_list(server_infos, server_id));
ASSERT_EQ(OB_ERROR, server_manager_.receive_hb(lq, server_id, to_alive, update_delay_time_flag));
ASSERT_EQ(OB_SUCCESS, server_manager_.check_server_alive(lq.server_, is_alive));
ASSERT_TRUE(is_alive);
const int64_t now = ::oceanbase::common::ObTimeUtility::current_time();
ObServerStatus server_status;
ObAddr server;
server = B;
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(server, server_status));
server_status.last_hb_time_ = now - config_.lease_time - 4000000L;
ASSERT_EQ(OB_SUCCESS, server_manager_.update_server_status(server_status));
ASSERT_EQ(OB_ERROR, server_manager_.check_servers());
}
TEST_F(TestServerManager, heartbeatchecker)
{
ObHeartbeatChecker checker;
ASSERT_EQ(OB_SUCCESS, checker.init(server_manager_));
ASSERT_EQ(OB_INIT_TWICE, checker.init(server_manager_));
checker.start();
usleep(200 * 100 * 1000L); // check_server will be invoked 200 times
ObServerStatus server_status;
ObAddr server;
server = B;
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(server, server_status));
ASSERT_FALSE(server_status.is_active());
checker.stop();
checker.wait();
}
//TEST_F(TestServerManager, maintain_server)
//{
// ObLeaseRequest lq;
// uint64_t server_id = OB_INVALID_ID;
// bool to_alive = false;
// lq.server_ = E;
// lq.zone_ = "2";
// lq.inner_port_ = 3306;
// lq.resource_info_.cpu_ = 1;
// lq.resource_info_.mem_in_use_ = 0;
// lq.resource_info_.mem_total_ = 1024;
// lq.resource_info_.disk_in_use_ = 0;
// lq.resource_info_.disk_total_ = 1024;
// ASSERT_TRUE(strlen("dev1.0") == snprintf(lq.build_version_, OB_SERVER_VERSION_LENGTH,
// "%s", "dev1.0"));
// ASSERT_EQ(OB_SERVER_NOT_IN_WHITE_LIST, server_manager_.receive_hb(lq, server_id, to_alive));
// bool is_alive = false;
// ASSERT_EQ(OB_SUCCESS, server_manager_.check_server_alive(lq.server_, is_alive));
// ASSERT_FALSE(is_alive);
//
// // add server
// ObAddr invalid_server;
// ASSERT_EQ(OB_INVALID_ARGUMENT, server_manager_.add_server(invalid_server, lq.zone_));
// ASSERT_EQ(OB_SUCCESS, server_manager_.add_server(lq.server_, lq.zone_));
// ASSERT_EQ(OB_ENTRY_EXIST, server_manager_.add_server(lq.server_, lq.zone_));
// ASSERT_EQ(OB_INVALID_ARGUMENT, server_manager_.start_server(invalid_server, lq.zone_));
// ASSERT_EQ(OB_SERVER_ZONE_NOT_MATCH, server_manager_.start_server(lq.server_, "5"));
// ASSERT_EQ(OB_SUCCESS, server_manager_.start_server(lq.server_, lq.zone_));
// ObServerStatus server_status;
// ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(lq.server_, server_status));
// ASSERT_FALSE(server_status.is_active());
// ASSERT_EQ(OB_SUCCESS, server_manager_.receive_hb(lq, server_id, to_alive));
// ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(lq.server_, server_status));
// ASSERT_TRUE(server_status.is_active());
// ObLeaseRequest not_match_lq = lq;
// not_match_lq.zone_ = "1";
// ASSERT_EQ(OB_SERVER_ZONE_NOT_MATCH, server_manager_.receive_hb(not_match_lq, server_id, to_alive));
//
// ObAddr not_exist_server;
// not_exist_server = A1;
// ObZone not_match_zone = "1";
// // delete server, invalid server and not exist server
// ASSERT_EQ(OB_INVALID_ARGUMENT, server_manager_.delete_server(to_array(invalid_server), not_match_zone));
// ASSERT_EQ(OB_ENTRY_NOT_EXIST, server_manager_.delete_server(to_array(not_exist_server), not_match_zone));
// ASSERT_EQ(OB_INVALID_ARGUMENT, server_manager_.end_delete_server(invalid_server, not_match_zone));
// ASSERT_EQ(OB_ENTRY_NOT_EXIST, server_manager_.end_delete_server(not_exist_server, not_match_zone));
//
// //add or stop server, invalid server and not exist server
// ASSERT_EQ(OB_INVALID_ARGUMENT, server_manager_.start_server(invalid_server, not_match_zone));
// ASSERT_EQ(OB_ENTRY_NOT_EXIST, server_manager_.start_server(not_exist_server, not_match_zone));
// ASSERT_EQ(OB_INVALID_ARGUMENT, server_manager_.stop_server(invalid_server, not_match_zone));
// ASSERT_EQ(OB_ENTRY_NOT_EXIST, server_manager_.stop_server(not_exist_server, not_match_zone));
//
// //stop server twice
// ASSERT_EQ(OB_SUCCESS, server_manager_.stop_server(lq.server_, lq.zone_));
// ASSERT_EQ(OB_SUCCESS, server_manager_.stop_server(lq.server_, lq.zone_));
// //start server again
// ASSERT_EQ(OB_SUCCESS, server_manager_.start_server(lq.server_, lq.zone_));
// ASSERT_EQ(OB_SUCCESS, server_manager_.start_server(lq.server_, lq.zone_));
// //stop servers in multiple zone
// ObAddr server;
// server = A;
// ASSERT_EQ(OB_SUCCESS, server_manager_.stop_server(lq.server_, lq.zone_));
// ASSERT_EQ(OB_STOP_SERVER_IN_MULTIPLE_ZONES, server_manager_.stop_server(server, "1"));
//
// // delete server, then cancel delete
// ASSERT_EQ(OB_SERVER_ZONE_NOT_MATCH, server_manager_.delete_server(to_array(lq.server_), not_match_zone));
// ASSERT_EQ(OB_SUCCESS, server_manager_.delete_server(to_array(lq.server_), lq.zone_));
// ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(lq.server_, server_status));
// ASSERT_EQ(ObServerStatus::OB_SERVER_DELETING, server_status.get_display_status());
// ASSERT_EQ(OB_SERVER_ZONE_NOT_MATCH, server_manager_.delete_server(to_array(lq.server_), not_match_zone));
// ASSERT_EQ(OB_SUCCESS, server_manager_.end_delete_server(lq.server_, lq.zone_, false));
// ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(lq.server_, server_status));
// ASSERT_EQ(ObServerStatus::OB_SERVER_ACTIVE, server_status.get_display_status());
// ASSERT_EQ(OB_SERVER_NOT_DELETING, server_manager_.end_delete_server(lq.server_, lq.zone_, false));
//
// // delete server, then commit delete
// ASSERT_EQ(OB_SUCCESS, server_manager_.delete_server(to_array(lq.server_), lq.zone_));
// ASSERT_EQ(OB_SUCCESS, server_manager_.end_delete_server(lq.server_, lq.zone_, true));
// ASSERT_EQ(OB_ENTRY_NOT_EXIST, server_manager_.get_server_status(lq.server_, server_status));
// ASSERT_EQ(OB_ENTRY_NOT_EXIST, server_manager_.end_delete_server(lq.server_, lq.zone_, true));
// ASSERT_EQ(OB_ENTRY_NOT_EXIST, server_manager_.delete_server(to_array(lq.server_), lq.zone_));
//
// ObZone not_exist_zone = "not_exist";
// ASSERT_EQ(OB_ZONE_NOT_ACTIVE, server_manager_.add_server(lq.server_, not_exist_zone));
// ASSERT_EQ(OB_SUCCESS, server_manager_.add_server(lq.server_, lq.zone_));
// ASSERT_EQ(OB_SERVER_ZONE_NOT_MATCH, server_manager_.delete_server(to_array(lq.server_), not_exist_zone));
// ASSERT_EQ(OB_SERVER_ZONE_NOT_MATCH, server_manager_.end_delete_server(lq.server_, not_exist_zone, true));
//
// // empty server, delete then add server again
// ObAddr empty_server;
// empty_server.set_ip_addr("127.0.0.1", 1111);
// ASSERT_EQ(OB_SUCCESS, server_manager_.add_server(empty_server, "1"));
// ASSERT_EQ(OB_SUCCESS, server_manager_.delete_server(to_array(empty_server), "1"));
// ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(empty_server, server_status));
// ASSERT_EQ(OB_SUCCESS, server_manager_.end_delete_server(empty_server, server_status.zone_, true));
// ASSERT_EQ(OB_ENTRY_NOT_EXIST, server_manager_.get_server_status(empty_server, server_status));
// ASSERT_EQ(OB_SUCCESS, server_manager_.add_server(empty_server, "1"));
//}
TEST_F(TestServerManager, update_merged_version)
{
ObAddr s1, s2, s3;
s1 = A;
s2 = B;
s3 = C;
ObLeaseRequest lq;
lq.zone_ = "1";
lq.server_ = s1;
lq.inner_port_ = 3306;
lq.resource_info_.cpu_ = 1;
lq.resource_info_.mem_in_use_ = 0;
lq.resource_info_.mem_total_ = 1024;
lq.resource_info_.disk_in_use_ = 0;
lq.resource_info_.disk_total_ = 1024;
uint64_t server_id;
bool to_alive = false;
bool update_delay_time_flag = false;
ASSERT_EQ(OB_SUCCESS, server_manager_.receive_hb(lq, server_id, to_alive, update_delay_time_flag));
lq.server_ = s2;
ASSERT_EQ(OB_SUCCESS, server_manager_.receive_hb(lq, server_id, to_alive, update_delay_time_flag));
lq.server_ = s3;
ASSERT_EQ(OB_SUCCESS, server_manager_.receive_hb(lq, server_id, to_alive, update_delay_time_flag));
bool merged = false;
ASSERT_EQ(OB_SUCCESS, server_manager_.update_merged_version(s1, 2, merged));
ASSERT_FALSE(merged);
ASSERT_EQ(OB_SUCCESS, server_manager_.update_merged_version(s2, 2, merged));
ASSERT_FALSE(merged);
ASSERT_EQ(OB_SUCCESS, server_manager_.update_merged_version(s3, 2, merged));
ASSERT_TRUE(merged);
}
TEST_F(TestServerManager, block_migrate_in)
{
ObAddr s1, not_exist_server;
s1 = B;
not_exist_server = A1;
bool is_block = true;
ASSERT_EQ(OB_SUCCESS, server_manager_.check_migrate_in_blocked(s1, is_block));
ASSERT_FALSE(is_block);
ASSERT_EQ(OB_SUCCESS, server_manager_.block_migrate_in(s1));
ASSERT_EQ(OB_SUCCESS, server_manager_.check_migrate_in_blocked(s1, is_block));
ASSERT_TRUE(is_block);
ASSERT_EQ(OB_SUCCESS, server_manager_.unblock_migrate_in(s1));
ASSERT_EQ(OB_SUCCESS, server_manager_.check_migrate_in_blocked(s1, is_block));
ASSERT_FALSE(is_block);
is_block = true;
ASSERT_EQ(OB_ENTRY_NOT_EXIST, server_manager_.check_migrate_in_blocked(not_exist_server, is_block));
ASSERT_EQ(OB_ENTRY_NOT_EXIST, server_manager_.block_migrate_in(not_exist_server));
}
TEST_F(TestServerManager, in_service)
{
ObAddr s1, not_exist_server;
s1 = A;
not_exist_server = A1;
bool in_service = false;
ASSERT_EQ(OB_SUCCESS, server_manager_.check_in_service(s1, in_service));
ASSERT_FALSE(in_service);
ObLeaseRequest lq;
lq.zone_ = "1";
lq.server_ = s1;
lq.start_service_time_ = ObTimeUtility::current_time();
lq.inner_port_ = 3306;
lq.resource_info_.cpu_ = 1;
lq.resource_info_.mem_in_use_ = 0;
lq.resource_info_.mem_total_ = 1024;
lq.resource_info_.disk_in_use_ = 0;
lq.resource_info_.disk_total_ = 1024;
uint64_t server_id;
bool to_alive = false;
bool update_delay_time_flag = false;
ASSERT_EQ(OB_SUCCESS, server_manager_.receive_hb(lq, server_id, to_alive, update_delay_time_flag));
ASSERT_EQ(OB_SUCCESS, server_manager_.check_in_service(s1, in_service));
ASSERT_TRUE(in_service);
in_service = false;
ASSERT_EQ(OB_ENTRY_NOT_EXIST, server_manager_.check_in_service(not_exist_server, in_service));
}
TEST_F(TestServerManager, with_partition)
{
ASSERT_EQ(OB_SUCCESS, server_manager_.set_with_partition(B));
ASSERT_NE(OB_SUCCESS, server_manager_.set_with_partition(A)); // non-alive can not set with partition flag
ObServerStatus A_s;
ObServerStatus B_s;
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(A, A_s));
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(B, B_s));
ASSERT_TRUE(B_s.with_partition_);
ASSERT_EQ(OB_SUCCESS, server_manager_.clear_with_partition(A, A_s.last_hb_time_));
// last hb time mismatch, return success, keep with partition flag unchanged.
ASSERT_EQ(OB_SUCCESS, server_manager_.clear_with_partition(B, B_s.last_hb_time_ + 1));
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(B, B_s));
ASSERT_TRUE(B_s.with_partition_);
ASSERT_EQ(OB_SUCCESS, server_manager_.clear_with_partition(B, B_s.last_hb_time_));
ASSERT_EQ(OB_SUCCESS, server_manager_.get_server_status(B, B_s));
ASSERT_FALSE(B_s.with_partition_);
}
}//end namespace rootserver
}//end namespace oceanbase
int main(int argc, char **argv)
{
system("rm -f test_server_manager.log*");
ObLogger &logger = ObLogger::get_logger();
logger.set_file_name("test_server_manager.log", true);
logger.set_log_level(OB_LOG_LEVEL_INFO);
::testing::InitGoogleTest(&argc,argv);
oceanbase::common::ObTenantManager::get_instance().init(10);
oceanbase::common::ObTenantManager::get_instance().add_tenant(OB_SYS_TENANT_ID);
oceanbase::common::ObTenantManager::get_instance().set_tenant_mem_limit(OB_SYS_TENANT_ID, 1024L * 1024L * 1024L, 1024L * 1024L * 1024L);
return RUN_ALL_TESTS();
}
Reference in New Issue View Git Blame Copy Permalink