381 lines
11 KiB
C++
381 lines
11 KiB
C++
/**
|
|
* 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 SHARE
|
|
#include "share/ob_lease_struct.h"
|
|
#include "lib/utility/ob_print_utils.h"
|
|
#include "lib/utility/ob_serialization_helper.h"
|
|
namespace oceanbase
|
|
{
|
|
using namespace common;
|
|
namespace share
|
|
{
|
|
|
|
const char *server_service_status_to_str(const ServerServiceStatus status)
|
|
{
|
|
const char *str = "UNKNOWN";
|
|
switch (status) {
|
|
case OBSERVER_INVALID_STATUS:
|
|
str = "INVALID_STATUS";
|
|
break;
|
|
case OBSERVER_ACTIVE:
|
|
str = "ACTIVE";
|
|
break;
|
|
case OBSERVER_SWITCHING:
|
|
str = "SWITCHING";
|
|
break;
|
|
case OBSERVER_FLASHBACK_USER:
|
|
str = "FLASHBACK_USER";
|
|
break;
|
|
case OBSERVER_FLASHBACK_INNER:
|
|
str = "FLASHBACK_INNER";
|
|
break;
|
|
case OBSERVER_DISABLED:
|
|
str = "DISABLED";
|
|
break;
|
|
case OBSERVER_CLEANUP:
|
|
str = "CLEANUP";
|
|
break;
|
|
default:
|
|
str = "UNKNOWN";
|
|
break;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
ObServerResourceInfo::ObServerResourceInfo()
|
|
{
|
|
reset();
|
|
}
|
|
|
|
void ObServerResourceInfo::reset()
|
|
{
|
|
cpu_ = 0;
|
|
report_cpu_assigned_ = 0;
|
|
report_cpu_max_assigned_ = 0;
|
|
|
|
mem_total_ = 0;
|
|
report_mem_assigned_ = 0;
|
|
mem_in_use_ = 0;
|
|
|
|
log_disk_total_ = 0;
|
|
report_log_disk_assigned_ = 0;
|
|
|
|
disk_total_ = 0;
|
|
disk_in_use_ = 0;
|
|
|
|
// placeholders
|
|
log_disk_in_use_ = 0; // not used
|
|
report_data_disk_assigned_ = 0; // not used
|
|
}
|
|
|
|
bool ObServerResourceInfo::is_valid() const
|
|
{
|
|
return cpu_ > 0
|
|
&& report_cpu_assigned_ >= 0
|
|
&& report_cpu_max_assigned_ >= 0
|
|
&& mem_total_ > 0
|
|
&& report_mem_assigned_ >= 0
|
|
&& mem_in_use_ >= 0
|
|
&& log_disk_total_ > 0
|
|
&& report_log_disk_assigned_ >= 0
|
|
&& disk_total_ > 0
|
|
&& disk_in_use_ >= 0;
|
|
}
|
|
|
|
bool ObServerResourceInfo::operator==(const ObServerResourceInfo &other) const
|
|
{
|
|
return std::fabs(cpu_ - other.cpu_) < OB_DOUBLE_EPSINON
|
|
&& std::fabs(report_cpu_assigned_ - other.report_cpu_assigned_) < OB_DOUBLE_EPSINON
|
|
&& std::fabs(report_cpu_max_assigned_ - other.report_cpu_max_assigned_) < OB_DOUBLE_EPSINON
|
|
&& mem_total_ == other.mem_total_
|
|
&& report_mem_assigned_ == other.report_mem_assigned_
|
|
&& mem_in_use_ == other.mem_in_use_
|
|
&& log_disk_total_ == other.log_disk_total_
|
|
&& report_log_disk_assigned_ == other.report_log_disk_assigned_
|
|
&& disk_total_ == other.disk_total_
|
|
&& disk_in_use_ == other.disk_in_use_;
|
|
}
|
|
|
|
bool ObServerResourceInfo::operator!=(const ObServerResourceInfo &other) const
|
|
{
|
|
return std::fabs(cpu_ - other.cpu_) > OB_DOUBLE_EPSINON
|
|
|| std::fabs(report_cpu_assigned_ - other.report_cpu_assigned_) > OB_DOUBLE_EPSINON
|
|
|| std::fabs(report_cpu_max_assigned_ - other.report_cpu_max_assigned_) > OB_DOUBLE_EPSINON
|
|
|| mem_total_ != other.mem_total_
|
|
|| report_mem_assigned_ != other.report_mem_assigned_
|
|
|| mem_in_use_ != other.mem_in_use_
|
|
|| log_disk_total_ != other.log_disk_total_
|
|
|| report_log_disk_assigned_ != other.report_log_disk_assigned_
|
|
|| disk_total_ != other.disk_total_
|
|
|| disk_in_use_ != other.disk_in_use_;
|
|
}
|
|
|
|
int ObServerResourceInfo::assign(const ObServerResourceInfo& other)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
|
|
cpu_ = other.cpu_;
|
|
mem_in_use_ = other.mem_in_use_;
|
|
mem_total_ = other.mem_total_;
|
|
disk_in_use_ = other.disk_in_use_;
|
|
disk_total_ = other.disk_total_;
|
|
log_disk_total_ = other.log_disk_total_;
|
|
report_log_disk_assigned_ = other.report_log_disk_assigned_;
|
|
report_cpu_assigned_ = other.report_cpu_assigned_;
|
|
report_cpu_max_assigned_ = other.report_cpu_max_assigned_;
|
|
report_mem_assigned_ = other.report_mem_assigned_;
|
|
|
|
return ret;
|
|
}
|
|
|
|
OB_SERIALIZE_MEMBER(ObServerResourceInfo,
|
|
cpu_,
|
|
report_cpu_assigned_,
|
|
report_cpu_max_assigned_,
|
|
mem_total_,
|
|
report_mem_assigned_,
|
|
mem_in_use_,
|
|
log_disk_total_,
|
|
report_log_disk_assigned_,
|
|
disk_total_,
|
|
disk_in_use_,
|
|
report_data_disk_assigned_, // not used, only as placeholder
|
|
log_disk_in_use_); // not used, only as placeholder
|
|
|
|
DEF_TO_STRING(ObServerResourceInfo)
|
|
{
|
|
int64_t pos = 0;
|
|
J_OBJ_START();
|
|
(void)databuff_printf(buf, buf_len, pos,
|
|
"cpu_capacity:%.6g, "
|
|
"cpu_assigned:%.6g, "
|
|
"cpu_assigned_max:%.6g, "
|
|
"mem_capacity:\"%.9gGB\", "
|
|
"mem_assigned:\"%.9gGB\", "
|
|
"mem_in_use:%.9gGB, "
|
|
"log_disk_capacity:%.9gGB, "
|
|
"log_disk_assigned:%.9gGB, "
|
|
"data_disk_capacity:%.9gGB, "
|
|
"data_disk_in_use:%.9gGB",
|
|
cpu_,
|
|
report_cpu_assigned_,
|
|
report_cpu_max_assigned_,
|
|
(double)mem_total_/1024/1024/1024,
|
|
(double)report_mem_assigned_/1024/1024/1024,
|
|
(double)mem_in_use_/1024/1024/1024,
|
|
(double)log_disk_total_/1024/1024/1024,
|
|
(double)report_log_disk_assigned_/1024/1024/1024,
|
|
(double)disk_total_/1024/1024/1024,
|
|
(double)disk_in_use_/1024/1024/1024);
|
|
J_OBJ_END();
|
|
return pos;
|
|
}
|
|
|
|
|
|
OB_SERIALIZE_MEMBER(ObLeaseRequest::TLRqKeyVersion,
|
|
max_flushed_key_version_);
|
|
|
|
ObLeaseRequest::ObLeaseRequest()
|
|
{
|
|
reset();
|
|
}
|
|
|
|
void ObLeaseRequest::reset()
|
|
{
|
|
version_ = LEASE_VERSION;
|
|
zone_.reset();
|
|
server_.reset();
|
|
memset(build_version_, 0, OB_SERVER_VERSION_LENGTH);
|
|
sql_port_ = 0;
|
|
resource_info_.reset();
|
|
start_service_time_ = 0;
|
|
current_server_time_ = 0;
|
|
round_trip_time_ = 0;
|
|
server_status_ = 0;
|
|
ssl_key_expired_time_ = 0;
|
|
tenant_config_version_.reset();
|
|
timeout_partition_ = 0;
|
|
tenant_max_flushed_key_version_.reset();
|
|
request_lease_time_ = 0;
|
|
}
|
|
|
|
bool ObLeaseRequest::is_valid() const
|
|
{
|
|
// No need to determine the value of server_status_
|
|
return version_ > 0 && !zone_.is_empty() && server_.is_valid()
|
|
&& sql_port_ > 0 && resource_info_.is_valid()
|
|
&& start_service_time_ >= 0;
|
|
}
|
|
|
|
OB_SERIALIZE_MEMBER(ObLeaseRequest,
|
|
version_,
|
|
zone_,
|
|
server_,
|
|
sql_port_,
|
|
build_version_,
|
|
resource_info_,
|
|
start_service_time_,
|
|
current_server_time_,
|
|
round_trip_time_,
|
|
server_status_,
|
|
tenant_config_version_,
|
|
ssl_key_expired_time_,
|
|
timeout_partition_,
|
|
request_lease_time_,
|
|
tenant_max_flushed_key_version_);
|
|
|
|
OB_SERIALIZE_MEMBER(ObLeaseResponse::TLRpKeyVersion,
|
|
max_key_version_,
|
|
max_available_key_version_);
|
|
|
|
ObLeaseResponse::ObLeaseResponse()
|
|
{
|
|
reset();
|
|
}
|
|
|
|
void ObLeaseResponse::reset()
|
|
{
|
|
version_ = LEASE_VERSION;
|
|
lease_expire_time_ = -1;
|
|
lease_info_version_ = 0;
|
|
frozen_version_ = 0;
|
|
schema_version_ = 0;
|
|
server_id_ = OB_INVALID_ID;
|
|
frozen_status_.reset();
|
|
force_frozen_status_ = false;
|
|
rs_server_status_ = RSS_INVALID;
|
|
refresh_schema_info_.reset();
|
|
server_service_status_ = OBSERVER_INVALID_STATUS;
|
|
tenant_config_version_.reset();
|
|
baseline_schema_version_ = 0;
|
|
heartbeat_expire_time_ = -1;
|
|
tenant_max_key_version_.reset();
|
|
}
|
|
|
|
int ObLeaseResponse::assign(const ObLeaseResponse &other)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
version_ = other.version_;
|
|
lease_expire_time_ = other.lease_expire_time_;
|
|
lease_info_version_ = other.lease_info_version_;
|
|
frozen_version_ = other.frozen_version_;
|
|
schema_version_ = other.schema_version_;
|
|
server_id_ = other.server_id_;
|
|
frozen_status_ = other.frozen_status_;
|
|
force_frozen_status_ = other.force_frozen_status_;
|
|
rs_server_status_ = other.rs_server_status_;
|
|
server_service_status_ = other.server_service_status_;
|
|
baseline_schema_version_ = other.baseline_schema_version_;
|
|
heartbeat_expire_time_ = other.heartbeat_expire_time_;
|
|
if (OB_FAIL(refresh_schema_info_.assign(other.refresh_schema_info_))) {
|
|
LOG_WARN("failed to assign ohter schema info", KR(ret), "this", *this, K(other));
|
|
} else if (OB_FAIL(tenant_config_version_.assign(other.tenant_config_version_))) {
|
|
LOG_WARN("failed to assign tenant config version", KR(ret), K(other), "this", *this);
|
|
} else if (OB_FAIL(tenant_max_key_version_.assign(
|
|
other.tenant_max_key_version_))) {
|
|
LOG_WARN("failed to assign tenant max available key version", KR(ret));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
OB_SERIALIZE_MEMBER(ObLeaseResponse,
|
|
version_,
|
|
lease_expire_time_,
|
|
lease_info_version_,
|
|
frozen_version_,
|
|
schema_version_,
|
|
server_id_,
|
|
frozen_status_,
|
|
force_frozen_status_,
|
|
rs_server_status_,
|
|
refresh_schema_info_,
|
|
server_service_status_,
|
|
tenant_config_version_,
|
|
baseline_schema_version_,
|
|
heartbeat_expire_time_,
|
|
tenant_max_key_version_);
|
|
|
|
|
|
bool ObLeaseResponse::is_valid() const
|
|
{
|
|
// other member may be invalid value while RS restart.
|
|
return version_ > 0
|
|
&& schema_version_ > 0
|
|
&& heartbeat_expire_time_ > 0;
|
|
}
|
|
|
|
int ObLeaseResponse::set(const ObLeaseResponse &that)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
version_ = that.version_;
|
|
if (lease_expire_time_ < that.lease_expire_time_) {
|
|
lease_expire_time_ = that.lease_expire_time_;
|
|
}
|
|
lease_info_version_ = that.lease_info_version_;
|
|
frozen_version_ = that.frozen_version_;
|
|
schema_version_ = that.schema_version_;
|
|
server_id_ = that.server_id_;
|
|
frozen_status_ = that.frozen_status_;
|
|
force_frozen_status_ = that.force_frozen_status_;
|
|
rs_server_status_ = that.rs_server_status_;
|
|
refresh_schema_info_ = that.refresh_schema_info_;
|
|
server_service_status_ = that.server_service_status_;
|
|
baseline_schema_version_ = that.baseline_schema_version_;
|
|
heartbeat_expire_time_ = that.heartbeat_expire_time_;
|
|
if (OB_FAIL(tenant_config_version_.assign(that.tenant_config_version_))) {
|
|
SHARE_LOG(WARN, "fail to assign array", K(ret));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
bool ObZoneLeaseInfo::is_valid() const
|
|
{
|
|
return !zone_.is_empty() && privilege_version_ >= 0 && config_version_ >= 0
|
|
&& lease_info_version_ >= 0 && time_zone_info_version_ >= 0;
|
|
}
|
|
|
|
// ====================== ObInZoneHbRequest =======================
|
|
bool ObInZoneHbRequest::is_valid() const
|
|
{
|
|
return server_.is_valid();
|
|
}
|
|
|
|
void ObInZoneHbRequest::reset()
|
|
{
|
|
server_.reset();
|
|
}
|
|
|
|
OB_SERIALIZE_MEMBER(ObInZoneHbRequest,
|
|
server_);
|
|
|
|
// =================== ObInZoneHbResponse =====================
|
|
bool ObInZoneHbResponse::is_valid() const
|
|
{
|
|
/* in_zone_hb_expire_time_ > 0 时表示in_zone_mgr还在继续授予heartbeat,
|
|
* in_zone_hb_expire_time_ == 0 时表示in_zone_mgr不再授予heartbeat了
|
|
* in_zone_hb_expire_time_ < 0 是表示无效
|
|
*/
|
|
return in_zone_hb_expire_time_ >= 0;
|
|
}
|
|
|
|
void ObInZoneHbResponse::reset()
|
|
{
|
|
in_zone_hb_expire_time_ = -1;
|
|
}
|
|
|
|
OB_SERIALIZE_MEMBER(ObInZoneHbResponse,
|
|
in_zone_hb_expire_time_);
|
|
|
|
} // end namespace share
|
|
} // end namespace oceanbase
|