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

Do not report ERROR when sample rate equals 100

Browse Source
This commit is contained in:
ZenoWang
2024-02-06 14:49:31 +00:00
committed by ob-robot
parent 1f1d5c08ae
commit c8ef409bf3
3710 changed files with 486984 additions and 3083329 deletions
Download Patch File Download Diff File Expand all files Collapse all files

612
src/observer/ob_rpc_processor_simple.cpp
View File

@ -45,7 +45,6 @@
// for 4.0
#include "share/ob_ls_id.h"
#include "storage/ddl/ob_tablet_ddl_kv_mgr.h"
#include "storage/ddl/ob_direct_insert_sstable_ctx_new.h"
#include "storage/ls/ob_ls.h"
#include "storage/tablet/ob_tablet.h"
#include "storage/tx/ob_trans_service.h"
@ -54,7 +53,6 @@
#include "share/sequence/ob_sequence_cache.h"
#include "logservice/ob_log_service.h"
#include "logservice/ob_log_handler.h"
#include "logservice/archiveservice/ob_archive_service.h"
#include "share/scn.h"
#include "storage/ob_common_id_utils.h"
#include "storage/high_availability/ob_storage_ha_service.h"
@ -63,27 +61,18 @@
#include "storage/slog_ckpt/ob_tenant_checkpoint_slog_handler.h"
#include "observer/ob_req_time_service.h"
#include "observer/ob_server_event_history_table_operator.h"
#include "rootserver/ob_primary_ls_service.h"//PrimaryLSService
#include "rootserver/ob_tenant_transfer_service.h" // ObTenantTransferService
#include "storage/high_availability/ob_transfer_service.h" // ObTransferService
#include "sql/udr/ob_udr_mgr.h"
#include "rootserver/tenant_snapshot/ob_tenant_snapshot_scheduler.h"
#include "rootserver/restore/ob_clone_scheduler.h"
#ifdef OB_BUILD_SPM
#include "sql/spm/ob_spm_controller.h"
#endif
#include "sql/plan_cache/ob_ps_cache.h"
#include "pl/pl_cache/ob_pl_cache_mgr.h"
#include "rootserver/ob_admin_drtask_util.h" // ObAdminDRTaskUtil
#include "rootserver/ob_primary_ls_service.h" // for ObPrimaryLSService
#include "rootserver/ob_root_utils.h"
#include "sql/session/ob_sql_session_info.h"
#include "sql/session/ob_sess_info_verify.h"
#include "observer/table/ttl/ob_ttl_service.h"
#include "storage/tenant_snapshot/ob_tenant_snapshot_service.h"
#include "storage/high_availability/ob_storage_ha_utils.h"
#include "share/ob_rpc_struct.h"
#include "rootserver/ob_recovery_ls_service.h"
#include "logservice/ob_server_log_block_mgr.h"
namespace oceanbase
{
@ -189,7 +178,52 @@ int ObRpcLSMigrateReplicaP::process()
int ObRpcLSAddReplicaP::process()
{
return observer::ObService::do_add_ls_replica(arg_);
int ret = OB_SUCCESS;
uint64_t tenant_id = arg_.tenant_id_;
ObLSService *ls_service = nullptr;
bool is_exist = false;
ObMigrationOpArg migration_op_arg;
if (tenant_id != MTL_ID()) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("ObRpcLSAddReplicaP::process tenant not match", K(tenant_id), K(ret));
}
ObCurTraceId::set(arg_.task_id_);
if (OB_SUCC(ret)) {
SERVER_EVENT_ADD("storage_ha", "schedule_ls_add start", "tenant_id", arg_.tenant_id_, "ls_id", arg_.ls_id_.id(),
"data_src", arg_.data_source_.get_server(), "dest", arg_.dst_.get_server());
ls_service = MTL(ObLSService*);
if (OB_ISNULL(ls_service)) {
ret = OB_ERR_UNEXPECTED;
COMMON_LOG(ERROR, "mtl ObLSService should not be null", K(ret));
} else if (OB_FAIL(ls_service->check_ls_exist(arg_.ls_id_, is_exist))) {
COMMON_LOG(WARN, "failed to check ls exist", K(ret), K(arg_));
} else if (is_exist) {
ret = OB_LS_EXIST;
COMMON_LOG(WARN, "can not add ls which local ls is exist", K(ret), K(arg_), K(is_exist));
} else {
migration_op_arg.cluster_id_ = GCONF.cluster_id;
migration_op_arg.data_src_ = arg_.data_source_;
migration_op_arg.dst_ = arg_.dst_;
migration_op_arg.ls_id_ = arg_.ls_id_;
//TODO(muwei.ym) need check priority in 4.2 RC3
migration_op_arg.priority_ = ObMigrationOpPriority::PRIO_HIGH;
migration_op_arg.paxos_replica_number_ = arg_.new_paxos_replica_number_;
migration_op_arg.src_ = arg_.data_source_;
migration_op_arg.type_ = ObMigrationOpType::ADD_LS_OP;
if (OB_FAIL(ls_service->create_ls_for_ha(arg_.task_id_, migration_op_arg))) {
COMMON_LOG(WARN, "failed to create ls for ha", K(ret), K(arg_), K(migration_op_arg));
}
}
}
if (OB_FAIL(ret)) {
SERVER_EVENT_ADD("storage_ha", "schedule_ls_add failed", "tenant_id", arg_.tenant_id_,
"ls_id", arg_.ls_id_, "result", ret);
}
return ret;
}
int ObRpcLSTypeTransformP::process()
@ -235,12 +269,80 @@ int ObRpcLSTypeTransformP::process()
int ObRpcLSRemovePaxosReplicaP::process()
{
return observer::ObService::do_remove_ls_paxos_replica(arg_);
int ret = OB_SUCCESS;
uint64_t tenant_id = arg_.tenant_id_;
MAKE_TENANT_SWITCH_SCOPE_GUARD(guard);
ObLSService *ls_service = nullptr;
ObLSHandle ls_handle;
ObLS *ls = nullptr;
if (tenant_id != MTL_ID()) {
ret = guard.switch_to(tenant_id);
}
ObCurTraceId::set(arg_.task_id_);
if (OB_SUCC(ret)) {
SERVER_EVENT_ADD("storage_ha", "remove_ls_paxos_member start", "tenant_id", arg_.tenant_id_, "ls_id", arg_.ls_id_.id(),
"dest", arg_.remove_member_.get_server());
LOG_INFO("start do remove ls paxos member", K(arg_));
ls_service = MTL(ObLSService*);
if (OB_ISNULL(ls_service)) {
ret = OB_ERR_UNEXPECTED;
COMMON_LOG(ERROR, "mtl ObLSService should not be null", K(ret));
} else if (OB_FAIL(ls_service->get_ls(arg_.ls_id_, ls_handle, ObLSGetMod::OBSERVER_MOD))) {
LOG_WARN("failed to get ls", K(ret), K(arg_));
} else if (OB_ISNULL(ls = ls_handle.get_ls())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("ls should not be NULL", K(ret), K(arg_));
} else if (OB_FAIL(ls->get_ls_remove_member_handler()->remove_paxos_member(arg_))) {
LOG_WARN("failed to remove paxos member", K(ret), K(arg_));
}
}
if (OB_FAIL(ret)) {
SERVER_EVENT_ADD("storage_ha", "remove_ls_paxos_member failed", "tenant_id",
arg_.tenant_id_, "ls_id", arg_.ls_id_.id(), "result", ret);
}
return ret;
}
int ObRpcLSRemoveNonPaxosReplicaP::process()
{
return observer::ObService::do_remove_ls_nonpaxos_replica(arg_);
int ret = OB_SUCCESS;
uint64_t tenant_id = arg_.tenant_id_;
MAKE_TENANT_SWITCH_SCOPE_GUARD(guard);
ObLSService *ls_service = nullptr;
ObLSHandle ls_handle;
ObLS *ls = nullptr;
if (tenant_id != MTL_ID()) {
ret = guard.switch_to(tenant_id);
}
ObCurTraceId::set(arg_.task_id_);
if (OB_SUCC(ret)) {
SERVER_EVENT_ADD("storage_ha", "remove_ls_learner_member start", "tenant_id", arg_.tenant_id_, "ls_id", arg_.ls_id_.id(),
"dest", arg_.remove_member_.get_server());
LOG_INFO("start do remove ls learner member", K(arg_));
ls_service = MTL(ObLSService*);
if (OB_ISNULL(ls_service)) {
ret = OB_ERR_UNEXPECTED;
COMMON_LOG(ERROR, "mtl ObLSService should not be null", K(ret));
} else if (OB_FAIL(ls_service->get_ls(arg_.ls_id_, ls_handle, ObLSGetMod::OBSERVER_MOD))) {
LOG_WARN("failed to get ls", K(ret), K(arg_));
} else if (OB_ISNULL(ls = ls_handle.get_ls())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("ls should not be NULL", K(ret), K(arg_));
} else if (OB_FAIL(ls->get_ls_remove_member_handler()->remove_learner_member(arg_))) {
LOG_WARN("failed to remove paxos member", K(ret), K(arg_));
}
}
if (OB_FAIL(ret)) {
SERVER_EVENT_ADD("storage_ha", "remove_ls_learner_member failed", "tenant_id",
arg_.tenant_id_, "ls_id", arg_.ls_id_.id(), "result", ret);
}
return ret;
}
int ObRpcLSModifyPaxosReplicaNumberP::process()
@ -331,21 +433,6 @@ int ObRpcLSCheckDRTaskExistP::process()
return ret;
}
int ObAdminDRTaskP::process()
{
int ret = OB_SUCCESS;
ObCurTraceId::init(GCONF.self_addr_);
LOG_INFO("start to handle ls replica task triggered by ob_admin", K_(arg));
if (OB_UNLIKELY(!arg_.is_valid())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K_(arg));
} else if (OB_FAIL(ObAdminDRTaskUtil::handle_obadmin_command(arg_))) {
LOG_WARN("fail to handle ob admin command", KR(ret), K_(arg));
}
LOG_INFO("finish handle ls replica task triggered by ob_admin", K_(arg));
return ret;
}
#ifdef OB_BUILD_ARBITRATION
int ObRpcAddArbP::process()
{
@ -425,15 +512,20 @@ int ObRpcSetTenantConfigP::process()
{
LOG_INFO("process set tenant config", K(arg_));
OTC_MGR.add_extra_config(arg_);
OTC_MGR.notify_tenant_config_changed(arg_.tenant_id_);
return OB_SUCCESS;
}
int ObRpcNotifyTenantServerUnitResourceP::process()
{
int ret = OB_SUCCESS;
if (OB_FAIL(ObTenantNodeBalancer::get_instance().handle_notify_unit_resource(arg_))) {
LOG_WARN("fail to handle_notify_unit_resource", K(ret), K_(arg));
if (arg_.is_delete_) {
if (OB_FAIL(ObTenantNodeBalancer::get_instance().try_notify_drop_tenant(arg_.tenant_id_))) {
LOG_WARN("fail to try drop tenant", K(ret), K(arg_));
}
} else {
if (OB_FAIL(ObTenantNodeBalancer::get_instance().notify_create_tenant(arg_))) {
LOG_WARN("failed to notify update tenant", K(ret), K_(arg));
}
}
return ret;
}
@ -932,6 +1024,7 @@ int ObDumpMemtableP::process()
ObLSService* ls_svr = nullptr;
ObTabletHandle tablet_handle;
ObLSHandle ls_handle;
ObIMemtableMgr *memtable_mgr = nullptr;
common::ObSEArray<ObTableHandleV2, 7> tables_handle;
if (OB_ISNULL(ls_svr = MTL(ObLSService*))) {
@ -954,8 +1047,11 @@ int ObDumpMemtableP::process()
} else if (OB_UNLIKELY(!tablet_handle.is_valid())) {
ret = OB_ERR_UNEXPECTED;
SERVER_LOG(WARN, "invalid tablet handle", K(ret), K(tablet_handle));
} else if (OB_FAIL(tablet_handle.get_obj()->get_all_memtables(tables_handle))) {
LOG_WARN("failed to get all memtable", K(ret), KPC(tablet_handle.get_obj()));
} else if (OB_ISNULL(memtable_mgr = tablet_handle.get_obj()->get_memtable_mgr())) {
ret = OB_ERR_UNEXPECTED;
SERVER_LOG(WARN, "memtable mgr is null", K(ret));
} else if (OB_FAIL(memtable_mgr->get_all_memtables(tables_handle))) {
SERVER_LOG(WARN, "fail to get all memtables for log stream", K(ret));
} else {
memtable::ObMemtable *mt;
mkdir("/tmp/dump_memtable/", S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
@ -1254,27 +1350,7 @@ int ObFlushCacheP::process()
break;
}
case CACHE_TYPE_PL_OBJ: {
if (arg_.is_fine_grained_) { // fine-grained plan cache evict
bool is_evict_by_schema_id = common::OB_INVALID_ID != arg_.schema_id_;
MTL_SWITCH(arg_.tenant_id_) {
ObPlanCache* plan_cache = MTL(ObPlanCache*);
if (arg_.db_ids_.count() == 0) {
if (is_evict_by_schema_id) {
ret = plan_cache->flush_pl_cache_single_cache_obj<pl::ObGetPLKVEntryBySchemaIdOp, uint64_t>(OB_INVALID_ID, arg_.schema_id_);
} else {
ret = plan_cache->flush_pl_cache_single_cache_obj<pl::ObGetPLKVEntryBySQLIDOp, ObString>(OB_INVALID_ID, arg_.sql_id_);
}
} else {
for (uint64_t i=0; i<arg_.db_ids_.count(); i++) {
if (is_evict_by_schema_id) {
ret = plan_cache->flush_pl_cache_single_cache_obj<pl::ObGetPLKVEntryBySchemaIdOp, uint64_t>(arg_.db_ids_.at(i), arg_.schema_id_);
} else {
ret = plan_cache->flush_pl_cache_single_cache_obj<pl::ObGetPLKVEntryBySQLIDOp, ObString>(arg_.db_ids_.at(i), arg_.sql_id_);
}
}
}
}
} else if (arg_.is_all_tenant_) {
if (arg_.is_all_tenant_) {
common::ObArray<uint64_t> tenant_ids;
if (OB_ISNULL(GCTX.omt_)) {
ret = OB_ERR_UNEXPECTED;
@ -1500,46 +1576,6 @@ int ObRpcCheckLSCanOfflineP::process()
return ret;
}
int ObRpcInnerCreateTenantSnapshotP::process()
{
int ret = OB_SUCCESS;
if (MTL_ID() != arg_.get_tenant_id()) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("ObRpcInnerCreateTenantSnapshotP::process tenant not match", KR(ret), K(arg_));
}
if (OB_SUCC(ret)) {
ObTenantSnapshotService *service = nullptr;
service = MTL(ObTenantSnapshotService*);
if (OB_ISNULL(service)) {
ret = OB_ERR_UNEXPECTED;
COMMON_LOG(ERROR, "mtl ObTenantSnapshotService should not be nullptr", KR(ret), K(arg_));
} else if (OB_FAIL(service->create_tenant_snapshot(arg_))) {
COMMON_LOG(WARN, "fail to create tenant snapshot", KR(ret), K(arg_));
}
}
return ret;
}
int ObRpcInnerDropTenantSnapshotP::process()
{
int ret = OB_SUCCESS;
if (MTL_ID() != arg_.get_tenant_id()) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("ObRpcInnerDropTenantSnapshotP::process tenant not match", KR(ret), K(arg_));
}
if (OB_SUCC(ret)) {
ObTenantSnapshotService *service = nullptr;
service = MTL(ObTenantSnapshotService*);
if (OB_ISNULL(service)) {
ret = OB_ERR_UNEXPECTED;
COMMON_LOG(ERROR, "mtl ObTenantSnapshotService should not be nullptr", KR(ret), K(arg_));
} else if (OB_FAIL(service->drop_tenant_snapshot(arg_))) {
COMMON_LOG(WARN, "fail to drop tenant snapshot", KR(ret), K(arg_));
}
}
return ret;
}
int ObRpcGetLSAccessModeP::process()
{
int ret = OB_SUCCESS;
@ -1609,14 +1645,13 @@ int ObRpcChangeLSAccessModeP::process()
}
if (OB_SUCC(ret)) {
ls_svr = MTL(ObLSService*);
logservice::ObLogService *log_ls_svr = MTL(logservice::ObLogService*);
ObLS *ls = nullptr;
ObLSID ls_id = arg_.get_ls_id();
ObLSHandle handle;
logservice::ObLogHandler *log_handler = NULL;
if (OB_ISNULL(ls_svr) || OB_ISNULL(log_ls_svr)) {
if (OB_ISNULL(ls_svr)) {
ret = OB_ERR_UNEXPECTED;
COMMON_LOG(ERROR, "mtl ObLSService or ObLogService should not be null", KR(ret), KP(ls_svr), KP(log_ls_svr));
COMMON_LOG(ERROR, "mtl ObLSService should not be null", K(ret));
} else if (OB_FAIL(ls_svr->get_ls(ls_id, handle, ObLSGetMod::OBSERVER_MOD))) {
COMMON_LOG(WARN, "get ls failed", KR(ret), K(ls_id));
} else if (OB_ISNULL(ls = handle.get_ls())) {
@ -1628,13 +1663,11 @@ int ObRpcChangeLSAccessModeP::process()
} else if (palf::AccessMode::RAW_WRITE == arg_.get_access_mode() && !ls_id.is_sys_ls()) {
// switchover to standby
// user ls end scn should be larger than sys ls end scn at first
DEBUG_SYNC(BEFORE_WAIT_SYS_LS_END_SCN);
if (OB_UNLIKELY(!arg_.get_sys_ls_end_scn().is_valid_and_not_min())) {
FLOG_WARN("invalid sys_ls_end_scn, no need to let user ls wait, "
"the version might be smaller than V4.2.0", KR(ret), K(arg_.get_sys_ls_end_scn()));
} else if (OB_FAIL(rootserver::ObRootUtils::wait_user_ls_sync_scn_locally(
} else if (OB_FAIL(share::ObShareUtil::wait_user_ls_sync_scn_locally(
arg_.get_sys_ls_end_scn(),
log_ls_svr,
*ls))) {
LOG_WARN("fail to wait user ls sync scn locally", KR(ret), K(ls_id), K(arg_.get_sys_ls_end_scn()));
}
@ -2117,43 +2150,6 @@ int ObSetRootKeyP::process()
}
return ret;
}
int ObCloneKeyP::process()
{
int ret = OB_SUCCESS;
const uint64_t source_tenant_id = arg_.get_source_tenant_id();
ObCipherOpMode mode;
common::ObSEArray<std::pair<uint64_t, ObMasterKey>, 2> master_key_list;
if (OB_UNLIKELY(!arg_.is_valid())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K(arg_));
//get master key info from source tenant
} else if (OB_FAIL(ObMasterKeyGetter::get_table_key_algorithm(source_tenant_id, mode))) {
LOG_WARN("failed to get table key algorithm", KR(ret), K(source_tenant_id));
} else if (OB_FAIL(ObMasterKeyGetter::instance().dump_tenant_keys(source_tenant_id,
master_key_list))) {
LOG_WARN("failed to dump tenant key", KR(ret), K(source_tenant_id));
//set master key info for clone tenant
} else if (OB_FAIL(ObMasterKeyGetter::instance().load_tenant_keys(arg_.get_tenant_id(),
mode,
master_key_list))) {
LOG_WARN("failed to load tenant keys", KR(ret), K(arg_));
}
return ret;
}
int ObTrimKeyListP::process()
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!arg_.is_valid())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K(arg_));
} else if (OB_FAIL(ObMasterKeyGetter::instance().trim_master_key_map(arg_.get_tenant_id(),
arg_.get_latest_master_key_id()))) {
LOG_WARN("fail to trim master key map", KR(ret), K(arg_));
}
return ret;
}
#endif
int ObHandlePartTransCtxP::process()
@ -2247,12 +2243,14 @@ int ObRpcRemoteWriteDDLRedoLogP::process()
} else {
MTL_SWITCH(tenant_id) {
ObRole role = INVALID_ROLE;
ObDDLRedoLogWriter sstable_redo_writer;
ObDDLSSTableRedoWriter sstable_redo_writer;
MacroBlockId macro_block_id;
ObMacroBlockHandle macro_handle;
ObMacroBlockWriteInfo write_info;
ObLSService *ls_service = MTL(ObLSService*);
ObLSHandle ls_handle;
ObTabletHandle tablet_handle;
ObDDLKvMgrHandle ddl_kv_mgr_handle;
ObLS *ls = nullptr;
// restruct write_info
@ -2270,15 +2268,19 @@ int ObRpcRemoteWriteDDLRedoLogP::process()
} else if (ObRole::LEADER != role) {
ret = OB_NOT_MASTER;
LOG_INFO("leader may not have finished replaying clog, caller retry", K(ret), K(MTL_ID()), K(arg_.ls_id_));
} else if (OB_FAIL(ls->get_tablet(arg_.redo_info_.table_key_.tablet_id_, tablet_handle))) {
LOG_WARN("get tablet failed", K(ret));
} else if (OB_FAIL(tablet_handle.get_obj()->get_ddl_kv_mgr(ddl_kv_mgr_handle))) {
LOG_WARN("get ddl kv manager failed", K(ret));
} else if (OB_FAIL(ObBlockManager::async_write_block(write_info, macro_handle))) {
LOG_WARN("fail to async write block", K(ret), K(write_info), K(macro_handle));
} else if (OB_FAIL(macro_handle.wait())) {
LOG_WARN("fail to wait macro block io finish", K(ret));
} else if (OB_FAIL(sstable_redo_writer.init(arg_.ls_id_, arg_.redo_info_.table_key_.tablet_id_))) {
LOG_WARN("init sstable redo writer", K(ret), K_(arg));
} else if (OB_FAIL(sstable_redo_writer.write_macro_block_log(arg_.redo_info_, macro_handle.get_macro_id(), false, arg_.task_id_))) {
} else if (OB_FAIL(sstable_redo_writer.write_redo_log(arg_.redo_info_, macro_handle.get_macro_id(), false, arg_.task_id_, tablet_handle, ddl_kv_mgr_handle))) {
LOG_WARN("fail to write macro redo", K(ret), K_(arg));
} else if (OB_FAIL(sstable_redo_writer.wait_macro_block_log_finish(arg_.redo_info_,
} else if (OB_FAIL(sstable_redo_writer.wait_redo_log_finish(arg_.redo_info_,
macro_handle.get_macro_id()))) {
LOG_WARN("fail to wait macro redo finish", K(ret), K_(arg));
}
@ -2295,15 +2297,12 @@ int ObRpcRemoteWriteDDLCommitLogP::process()
MTL_SWITCH(tenant_id) {
ObRole role = INVALID_ROLE;
const ObITable::TableKey &table_key = arg_.table_key_;
ObDDLRedoLogWriter sstable_redo_writer;
ObDDLSSTableRedoWriter sstable_redo_writer;
ObLSService *ls_service = MTL(ObLSService*);
ObLSHandle ls_handle;
ObTabletHandle tablet_handle;
ObDDLKvMgrHandle ddl_kv_mgr_handle;
ObLS *ls = nullptr;
ObTenantDirectLoadMgr *tenant_direct_load_mgr = MTL(ObTenantDirectLoadMgr *);
ObTabletFullDirectLoadMgr *data_tablet_mgr = nullptr;
ObTabletDirectLoadMgrHandle direct_load_mgr_handle;
direct_load_mgr_handle.reset();
bool is_major_sstable_exist = false;
if (OB_UNLIKELY(!arg_.is_valid())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(ret), K_(arg));
@ -2317,57 +2316,32 @@ int ObRpcRemoteWriteDDLCommitLogP::process()
} else if (ObRole::LEADER != role) {
ret = OB_NOT_MASTER;
LOG_INFO("leader may not have finished replaying clog, caller retry", K(ret), K(MTL_ID()), K(arg_.ls_id_));
} else if (OB_ISNULL(tenant_direct_load_mgr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected nullptr", K(ret), K(MTL_ID()));
} else if (OB_FAIL(tenant_direct_load_mgr->get_tablet_mgr_and_check_major(
arg_.ls_id_,
table_key.tablet_id_,
true /*is_full_direct_load*/,
direct_load_mgr_handle,
is_major_sstable_exist))) {
if (OB_ENTRY_NOT_EXIST == ret && is_major_sstable_exist) {
ret = OB_TASK_EXPIRED;
LOG_INFO("major sstable already exist", K(ret), K(arg_));
} else if (OB_FAIL(ls->get_tablet(table_key.tablet_id_, tablet_handle))) {
LOG_WARN("get tablet failed", K(ret));
} else if (OB_FAIL(tablet_handle.get_obj()->get_ddl_kv_mgr(ddl_kv_mgr_handle))) {
if (OB_ENTRY_NOT_EXIST == ret) {
ret = OB_EAGAIN;
} else {
LOG_WARN("get tablet direct load manager failed", K(ret), K(table_key));
LOG_WARN("get ddl kv manager failed", K(ret));
}
} else if (OB_ISNULL(data_tablet_mgr = direct_load_mgr_handle.get_full_obj())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected err", K(ret), K(table_key));
} else if (OB_FAIL(sstable_redo_writer.init(arg_.ls_id_, table_key.tablet_id_))) {
LOG_WARN("init sstable redo writer", K(ret), K(table_key));
} else if (FALSE_IT(sstable_redo_writer.set_start_scn(arg_.start_scn_))) {
} else {
uint32_t lock_tid = 0;
SCN commit_scn;
bool is_remote_write = false;
ObTabletHandle tablet_handle;
if (OB_FAIL(data_tablet_mgr->wrlock(ObTabletDirectLoadMgr::TRY_LOCK_TIMEOUT, lock_tid))) {
LOG_WARN("failed to wrlock", K(ret), K(arg_));
} else if (OB_FAIL(ls->get_tablet(table_key.tablet_id_, tablet_handle, ObTabletCommon::DEFAULT_GET_TABLET_DURATION_US, ObMDSGetTabletMode::READ_WITHOUT_CHECK))) {
LOG_WARN("get tablet failed", K(ret), K(table_key));
} else if (OB_FAIL(sstable_redo_writer.write_commit_log(false,
table_key,
arg_.start_scn_,
direct_load_mgr_handle,
tablet_handle,
commit_scn,
is_remote_write,
lock_tid))) {
if (OB_FAIL(sstable_redo_writer.write_commit_log(tablet_handle,
ddl_kv_mgr_handle,
false,
table_key,
commit_scn,
is_remote_write))) {
LOG_WARN("fail to remote write commit log", K(ret), K(table_key), K_(arg));
} else if (OB_FAIL(data_tablet_mgr->commit(*tablet_handle.get_obj(),
arg_.start_scn_,
commit_scn,
arg_.table_id_,
arg_.ddl_task_id_,
false/*is replay*/))) {
} else if (OB_FAIL(ddl_kv_mgr_handle.get_obj()->ddl_commit(*tablet_handle.get_obj(), arg_.start_scn_, commit_scn))) {
LOG_WARN("failed to do ddl kv commit", K(ret), K(arg_));
} else {
result_ = commit_scn.get_val_for_tx();
}
if (lock_tid != 0) {
data_tablet_mgr->unlock(lock_tid);
}
}
}
return ret;
@ -2613,10 +2587,8 @@ int ObRpcStartTransferTaskP::process()
{
int ret = OB_SUCCESS;
ObTransferService *transfer_service = nullptr;
const share::ObLSID &src_ls = arg_.get_src_ls();
const uint64_t tenant_id = arg_.get_tenant_id();
bool is_leader = false;
if (OB_UNLIKELY(tenant_id != MTL_ID())) {
if (OB_UNLIKELY(arg_.get_tenant_id() != MTL_ID())) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("ObRpcStartTransferTaskP::process tenant not match", KR(ret), K_(arg));
} else if (OB_UNLIKELY(!arg_.is_valid())) {
@ -2625,11 +2597,6 @@ int ObRpcStartTransferTaskP::process()
} else if (OB_ISNULL(transfer_service = MTL(ObTransferService *))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("ls service should not be null", K(ret), KP(transfer_service));
} else if (OB_FAIL(storage::ObStorageHAUtils::check_ls_is_leader(tenant_id, src_ls, is_leader))) {
LOG_WARN("fail to check ls is leader", K(ret), K(tenant_id), K(src_ls));
} else if (!is_leader) {
ret = OB_NOT_MASTER;
LOG_WARN("ls is not leader, please retry", K(ret), K(is_leader));
} else {
transfer_service->wakeup();
}
@ -2877,6 +2844,7 @@ int ObTenantTTLP::process()
RS_LOG(WARN, "fail to launch ttl", KR(ret), K(req));
}
res.err_code_ = ret;
ret = OB_SUCCESS;
return ret;
}
@ -2892,258 +2860,6 @@ int ObAdminUnlockMemberListP::process()
return ret;
}
int ObRpcNotifyTenantSnapshotSchedulerP::process()
{
int ret = OB_SUCCESS;
if (!arg_.is_valid()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K(arg_));
} else {
MTL_SWITCH(gen_meta_tenant_id(arg_.get_tenant_id())) {
rootserver::ObTenantSnapshotScheduler* tenant_snapshot_scheduler = MTL(rootserver::ObTenantSnapshotScheduler*);
if (OB_ISNULL(tenant_snapshot_scheduler)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("tenant snapshot scheduler is null", KR(ret), K(arg_));
} else {
tenant_snapshot_scheduler->wakeup();
}
}
}
(void)result_.init(ret);
return ret;
}
int ObRpcFlushLSArchiveP::process()
{
int ret = OB_SUCCESS;
uint64_t tenant_id = MTL_ID();
archive::ObArchiveService* archive_svr = MTL(archive::ObArchiveService*);
if (!arg_.is_valid() || tenant_id != arg_.tenant_id_) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K(arg_), K(tenant_id));
} else if (OB_ISNULL(archive_svr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("archive service is null", KR(ret), K(arg_));
} else {
archive_svr->flush_all();
}
result_ = ret;
return ret;
}
int ObRpcNotifyCloneSchedulerP::process()
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!arg_.is_valid())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K(arg_));
} else {
MTL_SWITCH(arg_.get_tenant_id()) {
rootserver::ObCloneScheduler* clone_scheduler = MTL(rootserver::ObCloneScheduler*);
if (OB_ISNULL(clone_scheduler)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("clone scheduler is null", KR(ret), K(arg_));
} else {
clone_scheduler->wakeup();
}
}
}
(void)result_.init(ret);
return ret;
}
int ObRpcNotifyTenantThreadP::process()
{
int ret = OB_SUCCESS;
LOG_INFO("receive notify tenant thread", K(arg_));
if (OB_UNLIKELY(!arg_.is_valid())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K(arg_));
} else {
MTL_SWITCH(arg_.get_tenant_id()) {
if (obrpc::ObNotifyTenantThreadArg::RECOVERY_LS_SERVICE == arg_.get_thread_type()) {
rootserver::ObRecoveryLSService *ls_service =
MTL(rootserver::ObRecoveryLSService *);
if (OB_ISNULL(ls_service)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("ls service is null", KR(ret), K(arg_));
} else {
ls_service->wakeup();
}
} else {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected thread type", KR(ret), K(arg_));
}
}
}
return ret;
}
int ObKillClientSessionP::process()
{
int ret = OB_SUCCESS;
ObSQLSessionInfo *session = NULL;
uint32_t server_sess_id = INVALID_SESSID;
if (OB_ISNULL(gctx_.session_mgr_)) {
ret = OB_ERR_UNEXPECTED;
COMMON_LOG(WARN, "session_mgr_ is null", KR(ret));
} else if (OB_FAIL(gctx_.session_mgr_->get_client_sess_map().get_refactored(
arg_.get_client_sess_id(), server_sess_id))) {
if (ret == OB_HASH_NOT_EXIST) {
// no need to display info, if current server no this proxy session id.
ret = OB_SUCCESS;
LOG_DEBUG("current client session id not find", K(ret), K(arg_.get_client_sess_id()));
} else {
COMMON_LOG(WARN, "get session failed", KR(ret), K(arg_));
}
} else if (OB_FAIL(gctx_.session_mgr_->get_session(server_sess_id, session))) {
LOG_INFO("fail to get session", K(ret), K(server_sess_id));
ret = OB_SUCCESS;
} else if (OB_ISNULL(session)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("session info is NULL", K(ret), K(arg_.get_client_sess_id()));
} else {
session->set_mark_killed(true);
// Ensure smooth exit of executed requests.
session->set_session_state(SESSION_KILLED);
}
if (NULL != session) {
gctx_.session_mgr_->revert_session(session);
}
if (OB_SUCC(ret)) {
// record kill_client_sess_map.
int flag = 1;
gctx_.session_mgr_->get_kill_client_sess_map().set_refactored(arg_.get_client_sess_id(),
arg_.get_create_time(), flag);
result_.set_can_kill_client_sess(true);
}
return ret;
}
int ObClientSessionConnectTimeP::process()
{
int ret = OB_SUCCESS;
ObSQLSessionInfo *session = NULL;
ObString str_result;
uint32_t server_sess_id = INVALID_SESSID;
if (OB_ISNULL(gctx_.session_mgr_)) {
ret = OB_ERR_UNEXPECTED;
COMMON_LOG(WARN, "session_mgr_ is null", KR(ret));
} else if (OB_FAIL(gctx_.session_mgr_->get_client_sess_map().get_refactored(
arg_.get_client_sess_id(), server_sess_id))) {
COMMON_LOG(WARN, "get session failed", KR(ret), K(arg_));
} else if (OB_FAIL(gctx_.session_mgr_->get_session(server_sess_id, session))) {
LOG_WARN("fail to get session", K(ret), K(server_sess_id));
} else if (OB_ISNULL(session)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("session info is NULL", K(ret), K(arg_.get_client_sess_id()));
} else {
result_.set_client_create_time(session->get_client_create_time());
if (((OB_SYS_TENANT_ID == arg_.get_tenant_id())
|| ((arg_.get_tenant_id() == session->get_priv_tenant_id())
&& (arg_.is_has_user_super_privilege() ||
arg_.get_user_id() == session->get_user_id())))) {
result_.set_have_kill_auth(true);
} else {
result_.set_have_kill_auth(false);
}
LOG_DEBUG("get connect time rpc", K(session->get_client_create_time()),
K(session->get_sessid()), K(session->get_client_sessid()));
}
if (NULL != session) {
gctx_.session_mgr_->revert_session(session);
}
return ret;
}
int ObTabletLocationReceiveP::process()
{
int ret = OB_SUCCESS;
if (OB_ISNULL(GCTX.location_service_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("GCTX.location_service_ is nullptr", KR(ret), KP(GCTX.location_service_));
} else {
FOREACH_CNT_X(it, arg_.get_tasks(), OB_SUCC(ret)) {
if (OB_FAIL(GCTX.location_service_->submit_tablet_update_task(*it))) {
LOG_WARN("failed to submit_tablet_update_tasks", KR(ret));
}
}
}
result_.set_ret(ret);
return OB_SUCCESS;
}
int ObCancelGatherStatsP::process()
{
int ret = OB_SUCCESS;
if (!arg_.is_valid()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arg", K(arg_), K(ret));
} else if (OB_FAIL(ObOptStatGatherStatList::instance().cancel_gather_stats(arg_.tenant_id_,
arg_.task_id_))) {
LOG_WARN("failed to cancel gather stats", K(ret));
}
return ret;
}
int ObForceSetTenantLogDiskP::process()
{
int ret = OB_SUCCESS;
if (!arg_.is_valid()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arg", K(ret));
} else if (OB_FAIL(GCTX.log_block_mgr_->force_update_tenant_log_disk(arg_.tenant_id_, arg_.log_disk_size_))) {
LOG_WARN("force_update_sys_tenant_log_disk failed", K(ret), "tenant_id", arg_.tenant_id_, "new_log_disk", arg_.log_disk_size_);
} else {
LOG_WARN("force_update_sys_tenant_log_disk success", K(ret), "tenant_id", arg_.tenant_id_, "new_log_disk", arg_.log_disk_size_);
}
return ret;
}
class ObDumpUnitInfoFunctor {
public:
ObDumpUnitInfoFunctor(ObSArray<ObDumpServerUsageResult::ObUnitInfo> &result) : result_(result) {}
int operator()()
{
int ret = OB_SUCCESS;
ObDumpServerUsageResult::ObUnitInfo info;
info.tenant_id_ = MTL_ID();
logservice::ObLogService *log_service = MTL(logservice::ObLogService*);
int64_t log_disk_size = 0, log_disk_in_use = 0;
if (OB_ISNULL(log_service)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("log_service is nullptr", KP(log_service));
} else if (OB_FAIL(log_service->get_palf_stable_disk_usage(log_disk_in_use, log_disk_size))) {
LOG_WARN("get_palf_stable_disk_usage failed", KP(log_service));
} else {
info.log_disk_in_use_ = log_disk_in_use;
info.log_disk_size_ = log_disk_size;
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(result_.push_back(info))) {
LOG_WARN("push_back failed", KR(ret), K(info));
}
return ret;
}
private:
ObSArray<ObDumpServerUsageResult::ObUnitInfo> &result_;
};
int ObForceDumpServerUsageP::process()
{
int ret = OB_SUCCESS;
int64_t &log_disk_assigned = result_.server_info_.log_disk_assigned_;
int64_t &log_disk_capacity = result_.server_info_.log_disk_capacity_;
ObSArray<ObDumpServerUsageResult::ObUnitInfo> &result = result_.unit_info_;
ObDumpUnitInfoFunctor dump_unit_info(result);
if (OB_FAIL(GCTX.omt_->operate_in_each_tenant(dump_unit_info))) {
CLOG_LOG(WARN, "operate_in_each_tenant failed", KR(ret));
} else if (OB_FAIL(GCTX.log_block_mgr_->get_disk_usage(log_disk_assigned, log_disk_capacity))) {
CLOG_LOG(WARN, "get_disk_usage failed", KR(ret));
} else {}
return ret;
}
} // end of namespace observer
} // end of namespace oceanbase