hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

fix tablet report logic

Browse Source
This commit is contained in:
obdev
2022-11-03 10:10:17 +00:00
committed by wangzelin.wzl
parent 6dba6ed96f
commit 17bea8074b
17 changed files with 323 additions and 948 deletions
Download Patch File Download Diff File Expand all files Collapse all files

164
src/observer/ob_service.cpp
View File

@ -164,7 +164,7 @@ ObService::ObService(const ObGlobalContext &gctx)
lease_state_mgr_(), heartbeat_process_(gctx, schema_updater_, lease_state_mgr_),
gctx_(gctx), server_trace_task_(), schema_release_task_(),
schema_status_task_(), remote_master_rs_update_task_(gctx), ls_table_updater_(),
tablet_table_updater_(), tablet_checksum_updater_(), meta_table_checker_()
tablet_table_updater_(), meta_table_checker_()
{
}
@ -205,8 +205,6 @@ int ObService::init(common::ObMySQLProxy &sql_proxy,
FLOG_WARN("init tablet table updater failed", KR(ret));
} else if (OB_FAIL(ls_table_updater_.init())) {
FLOG_WARN("init log stream table updater failed", KR(ret));
} else if (OB_FAIL(tablet_checksum_updater_.init(*this))) {
FLOG_WARN("init tablet checksum updater failed", KR(ret));
} else if (OB_FAIL(meta_table_checker_.init(
gctx_.lst_operator_,
gctx_.tablet_operator_,
@ -300,10 +298,6 @@ void ObService::stop()
tablet_table_updater_.stop();
FLOG_INFO("tablet table updater stopped");
FLOG_INFO("begin to stop tablet checksum updater");
tablet_checksum_updater_.stop();
FLOG_INFO("tablet checksum updater stopped");
FLOG_INFO("begin to stop meta table checker");
meta_table_checker_.stop();
FLOG_INFO("meta table checker stopped");
@ -329,10 +323,6 @@ void ObService::wait()
tablet_table_updater_.wait();
FLOG_INFO("wait tablet table updater success");
FLOG_INFO("begin to wait tablet checksum updater");
tablet_checksum_updater_.wait();
FLOG_INFO("wait tablet checksum updater success");
FLOG_INFO("begin to wait meta table checker");
meta_table_checker_.wait();
FLOG_INFO("wait meta table checker success");
@ -430,23 +420,6 @@ int ObService::submit_tablet_update_task(
return ret;
}
int ObService::submit_tablet_checksums_task(
const uint64_t tenant_id,
const ObLSID &ls_id,
const ObTabletID &tablet_id)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("not init", KR(ret));
} else if (!ls_id.is_valid_with_tenant(tenant_id) || !tablet_id.is_valid_with_tenant(tenant_id)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K(tenant_id), K(ls_id), K(tablet_id));
} else if (OB_FAIL(tablet_checksum_updater_.async_update(tenant_id, ls_id, tablet_id))) {
LOG_WARN("fail to async update tablet checksum", KR(ret), K(tenant_id), K(ls_id), K(tablet_id));
}
return ret;
}
int ObService::submit_async_refresh_schema_task(
const uint64_t tenant_id,
@ -1942,11 +1915,13 @@ int ObService::write_ddl_sstable_commit_log(const ObDDLWriteSSTableCommitLogArg
return ret;
}
int ObService::inner_fill_tablet_replica_(
int ObService::inner_fill_tablet_info_(
const int64_t tenant_id,
const ObTabletID &tablet_id,
storage::ObLS *ls,
ObTabletReplica &tablet_replica)
ObTabletReplica &tablet_replica,
share::ObTabletReplicaChecksumItem &tablet_checksum,
const bool need_checksum)
{
ObLSHandle ls_handle;
ObTabletHandle tablet_handle;
@ -1978,9 +1953,9 @@ int ObService::inner_fill_tablet_replica_(
const ObLSID &ls_id = ls->get_ls_id();
int64_t data_size = 0;
int64_t required_size = 0;
ObArray<int64_t> column_checksums; // param palceholder
ObArray<int64_t> column_checksums;
if (OB_FAIL(tablet_handle.get_obj()->get_tablet_report_info(column_checksums, data_size,
required_size, false/*need_checksum*/))) {
required_size, need_checksum))) {
LOG_WARN("fail to get tablet report info from tablet", KR(ret), K(tenant_id), K(tablet_id));
} else if (OB_FAIL(tablet_replica.init(
tenant_id,
@ -1992,66 +1967,29 @@ int ObService::inner_fill_tablet_replica_(
required_size))) {
LOG_WARN("fail to init a tablet replica", KR(ret), K(tenant_id),
K(tablet_id), K(tablet_replica));
}
}
return ret;
}
int ObService::inner_fill_tablet_replica_checksum_item_(
const int64_t tenant_id,
const ObTabletID &tablet_id,
storage::ObLS *ls,
share::ObTabletReplicaChecksumItem &item)
{
int ret = OB_SUCCESS;
ObTabletHandle tablet_handle;
if (OB_UNLIKELY(!inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("service not inited", KR(ret));
} else if (OB_UNLIKELY(!tablet_id.is_valid())
|| OB_INVALID_TENANT_ID == tenant_id
|| OB_ISNULL(ls)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument or nullptr", KR(ret), K(tablet_id), K(tenant_id));
} else if (OB_ISNULL(ls->get_tablet_svr())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get_tablet_svr is null", KR(ret), K(tenant_id), K(tablet_id));
} else if (OB_FAIL(ls->get_tablet_svr()->get_tablet(
tablet_id,
tablet_handle,
ObTabletCommon::NO_CHECK_GET_TABLET_TIMEOUT_US))) {
if (OB_TABLET_NOT_EXIST != ret) {
LOG_WARN("get tablet failed", KR(ret), K(tenant_id), K(tablet_id));
}
} else if (OB_ISNULL(gctx_.config_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("gctx_.config_ is null", KR(ret), K(tenant_id), K(tablet_id));
} else {
item.tenant_id_ = tenant_id;
item.ls_id_ = ls->get_ls_id();
item.tablet_id_ = tablet_id;
item.server_ = gctx_.self_addr();
item.row_count_ = tablet_handle.get_obj()->get_tablet_meta().report_status_.row_count_;
item.snapshot_version_ = tablet_handle.get_obj()->get_tablet_meta().report_status_.merge_snapshot_version_;
item.data_checksum_ = tablet_handle.get_obj()->get_tablet_meta().report_status_.data_checksum_;
int64_t data_size = 0;
int64_t required_size = 0;
ObArray<int64_t> column_checksums;
if (OB_FAIL(tablet_handle.get_obj()->get_tablet_report_info(column_checksums, data_size, required_size))) {
LOG_WARN("fail to get column checksums from tablet", KR(ret), K(tenant_id), K(tablet_id), K(item));
} else if (OB_FAIL(item.column_meta_.init(column_checksums))) {
} else if (!need_checksum) {
} else if (OB_FAIL(tablet_checksum.column_meta_.init(column_checksums))) {
LOG_WARN("fail to init report column meta with column_checksums", KR(ret), K(column_checksums));
} else {
tablet_checksum.tenant_id_ = tenant_id;
tablet_checksum.ls_id_ = ls->get_ls_id();
tablet_checksum.tablet_id_ = tablet_id;
tablet_checksum.server_ = gctx_.self_addr();
tablet_checksum.snapshot_version_ = snapshot_version;
tablet_checksum.row_count_ = tablet_handle.get_obj()->get_tablet_meta().report_status_.row_count_;
tablet_checksum.data_checksum_ = tablet_handle.get_obj()->get_tablet_meta().report_status_.data_checksum_;
}
}
return ret;
}
int ObService::fill_tablet_replica(
int ObService::fill_tablet_report_info(
const uint64_t tenant_id,
const ObLSID &ls_id,
const ObTabletID &tablet_id,
ObTabletReplica &tablet_replica)
ObTabletReplica &tablet_replica,
share::ObTabletReplicaChecksumItem &tablet_checksum,
const bool need_checksum)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!inited_)) {
@ -2077,62 +2015,18 @@ int ObService::fill_tablet_replica(
LOG_TRACE("log stream not exist in this tenant", KR(ret), K(tenant_id), K(ls_id));
}
} else if (FALSE_IT(ls = ls_handle.get_ls())) {
} else if (OB_FAIL(inner_fill_tablet_replica_(tenant_id,
tablet_id,
ls,
tablet_replica))) {
} else if (OB_FAIL(inner_fill_tablet_info_(tenant_id,
tablet_id,
ls,
tablet_replica,
tablet_checksum,
need_checksum))) {
if (OB_TABLET_NOT_EXIST != ret) {
LOG_WARN("fail to inner fill tenant's tablet replica", KR(ret),
K(tenant_id), K(tablet_id), K(ls), K(tablet_replica));
K(tenant_id), K(tablet_id), K(ls), K(tablet_replica), K(tablet_checksum), K(need_checksum));
} else {
LOG_TRACE("tablet not exist in this log stream", KR(ret),
K(tenant_id), K(tablet_id), K(ls), K(tablet_replica));
}
}
}
}
return ret;
}
int ObService::fill_tablet_replica_checksum_item(
const uint64_t tenant_id,
const share::ObLSID &ls_id,
const ObTabletID &tablet_id,
share::ObTabletReplicaChecksumItem &item)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("service not inited", KR(ret));
} else if (!tablet_id.is_valid() || !ls_id.is_valid() || OB_INVALID_TENANT_ID == tenant_id) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K(tablet_id), K(ls_id), K(tenant_id));
} else {
MTL_SWITCH(tenant_id) {
ObTabletHandle tablet_handle;
ObLSHandle ls_handle;
storage::ObLS *ls = nullptr;
ObLSService* ls_svr = nullptr;
if (OB_ISNULL(ls_svr = MTL(ObLSService*))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("MTL ObLSService is null", KR(ret), K(tenant_id));
} else if (OB_FAIL(ls_svr->get_ls(ls_id, ls_handle, ObLSGetMod::OBSERVER_MOD))) {
if (OB_LS_NOT_EXIST != ret) {
LOG_WARN("fail to get log_stream's ls_handle", KR(ret), K(tenant_id), K(ls_id));
} else {
LOG_TRACE("log stream not exist in this tenant", KR(ret), K(tenant_id), K(ls_id));
}
} else if (FALSE_IT(ls = ls_handle.get_ls())) {
} else if (OB_FAIL(inner_fill_tablet_replica_checksum_item_(tenant_id,
tablet_id,
ls,
item))) {
if (OB_TABLET_NOT_EXIST != ret) {
LOG_WARN("fail to inner fill tenant's tablet checksum item", KR(ret),
K(tenant_id), K(tablet_id), K(ls), K(item));
} else {
LOG_TRACE("tablet not exist in this log stream", KR(ret),
K(tenant_id), K(tablet_id), K(ls), K(item));
K(tenant_id), K(tablet_id), K(ls), K(tablet_replica), K(tablet_checksum), K(need_checksum));
}
}
}