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

using KPC to avoid core

Browse Source
This commit is contained in:
hamstersox
2022-12-06 07:37:48 +00:00
committed by ob-robot
parent 237b9e6734
commit 196359d85f
3 changed files with 88 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/rootserver/backup/ob_backup_data_ls_task_mgr.cpp
View File

@ -84,11 +84,11 @@ int ObBackupDataLSTaskMgr::process(int64_t &finish_cnt)
ret = OB_NOT_INIT; ret = OB_NOT_INIT;
LOG_WARN("[DATA_BACKUP]not init", K(ret)); LOG_WARN("[DATA_BACKUP]not init", K(ret));
} else { } else {
FLOG_INFO("[DATA_BACKUP]schedule backup ls task", K(*ls_attr_)); FLOG_INFO("[DATA_BACKUP]schedule backup ls task", KPC(ls_attr_));
switch (ls_attr_->status_.status_) { switch (ls_attr_->status_.status_) {
case ObBackupTaskStatus::Status::INIT: { case ObBackupTaskStatus::Status::INIT: {
if (OB_FAIL(gen_and_add_task_())) { if (OB_FAIL(gen_and_add_task_())) {
LOG_WARN("[DATA_BACKUP]failed to gen and add task into task schedulers", K(ret), K(*ls_attr_)); LOG_WARN("[DATA_BACKUP]failed to gen and add task into task schedulers", K(ret), KPC(ls_attr_));
} }
break; break;
} }
@ -97,13 +97,13 @@ int ObBackupDataLSTaskMgr::process(int64_t &finish_cnt)
break; break;
case ObBackupTaskStatus::Status::FINISH: { case ObBackupTaskStatus::Status::FINISH: {
if (OB_FAIL(finish_(finish_cnt))) { if (OB_FAIL(finish_(finish_cnt))) {
LOG_WARN("[DATA_BACKUP]failed to finish task", K(ret), K(*ls_attr_)); LOG_WARN("[DATA_BACKUP]failed to finish task", K(ret), KPC(ls_attr_));
} }
break; break;
} }
default: { default: {
ret = OB_ERR_SYS; ret = OB_ERR_SYS;
LOG_ERROR("[DATA_BACKUP]unknown backup task status", K(ret), K(*ls_attr_)); LOG_ERROR("[DATA_BACKUP]unknown backup task status", K(ret), KPC(ls_attr_));
} }
} }
} }
@ -127,31 +127,31 @@ int ObBackupDataLSTaskMgr::gen_and_add_task_()
#endif #endif
} }
if (OB_FAIL(gen_and_add_backup_data_task_())) { if (OB_FAIL(gen_and_add_backup_data_task_())) {
LOG_WARN("[DATA_BACKUP]failed to gen and add backup data task", K(ret), K(*ls_attr_)); LOG_WARN("[DATA_BACKUP]failed to gen and add backup data task", K(ret), KPC(ls_attr_));
} }
break; break;
} }
case ObBackupDataTaskType::Type::BACKUP_PLUS_ARCHIVE_LOG: { case ObBackupDataTaskType::Type::BACKUP_PLUS_ARCHIVE_LOG: {
if (OB_FAIL(gen_and_add_backup_compl_log_())) { if (OB_FAIL(gen_and_add_backup_compl_log_())) {
LOG_WARN("[DATA_BACKUP]failed to gen and add backup complement task", K(ret), K(*ls_attr_)); LOG_WARN("[DATA_BACKUP]failed to gen and add backup complement task", K(ret), KPC(ls_attr_));
} }
break; break;
} }
case ObBackupDataTaskType::Type::BACKUP_BUILD_INDEX: { case ObBackupDataTaskType::Type::BACKUP_BUILD_INDEX: {
if (OB_FAIL(gen_and_add_build_index_task_())) { if (OB_FAIL(gen_and_add_build_index_task_())) {
LOG_WARN("[DATA_BACKUP]failed to gen and add build index task", K(ret), K(*ls_attr_)); LOG_WARN("[DATA_BACKUP]failed to gen and add build index task", K(ret), KPC(ls_attr_));
} }
break; break;
} }
case ObBackupDataTaskType::Type::BACKUP_META: { case ObBackupDataTaskType::Type::BACKUP_META: {
if (OB_FAIL(gen_and_add_backup_meta_task_())) { if (OB_FAIL(gen_and_add_backup_meta_task_())) {
LOG_WARN("[DATA_BACKUP]failed to gen and add build index task", K(ret), K(*ls_attr_)); LOG_WARN("[DATA_BACKUP]failed to gen and add build index task", K(ret), KPC(ls_attr_));
} }
break; break;
} }
default: { default: {
ret = OB_ERR_SYS; ret = OB_ERR_SYS;
LOG_ERROR("[DATA_BACKUP]unknown backup ls task type", K(ret), K(*ls_attr_)); LOG_ERROR("[DATA_BACKUP]unknown backup ls task type", K(ret), KPC(ls_attr_));
} }
} }
return ret; return ret;
@ -194,11 +194,11 @@ int ObBackupDataLSTaskMgr::gen_and_add_backup_meta_task_()
LOG_WARN("fail to advance ls task status to finish", K(ret)); LOG_WARN("fail to advance ls task status to finish", K(ret));
} }
} else if (OB_FAIL(task.build(*job_attr_, *set_task_attr_, *ls_attr_))) { } else if (OB_FAIL(task.build(*job_attr_, *set_task_attr_, *ls_attr_))) {
LOG_WARN("[DATA_BACKUP]failed to build task", K(ret), K(*job_attr_), K(*set_task_attr_), K(*ls_attr_)); LOG_WARN("[DATA_BACKUP]failed to build task", K(ret), KPC(job_attr_), KPC(set_task_attr_), KPC(ls_attr_));
} else if (OB_FAIL(advance_status(*lease_service_, *sql_proxy_, *ls_attr_, next_status))) { } else if (OB_FAIL(advance_status(*lease_service_, *sql_proxy_, *ls_attr_, next_status))) {
LOG_WARN("[DATA_BACKUP]failed to advance task status", K(ret), K(*ls_attr_), K(next_status)); LOG_WARN("[DATA_BACKUP]failed to advance task status", K(ret), KPC(ls_attr_), K(next_status));
} else if (OB_FAIL(task_scheduler_->add_task(task))) { } else if (OB_FAIL(task_scheduler_->add_task(task))) {
LOG_WARN("[DATA_BACKUP]failed to add task", K(ret), K(*job_attr_), K(task)); LOG_WARN("[DATA_BACKUP]failed to add task", K(ret), KPC(job_attr_), K(task));
} }
return ret; return ret;
} }
@ -221,11 +221,11 @@ int ObBackupDataLSTaskMgr::gen_and_add_backup_data_task_()
LOG_WARN("fail to advance ls task status to finish", K(ret)); LOG_WARN("fail to advance ls task status to finish", K(ret));
} }
} else if (OB_FAIL(task.build(*job_attr_, *set_task_attr_, *ls_attr_))) { } else if (OB_FAIL(task.build(*job_attr_, *set_task_attr_, *ls_attr_))) {
LOG_WARN("[DATA_BACKUP]failed to build task", K(ret), K(*job_attr_), K(*set_task_attr_), K(*ls_attr_)); LOG_WARN("[DATA_BACKUP]failed to build task", K(ret), KPC(job_attr_), KPC(set_task_attr_), KPC(ls_attr_));
} else if (OB_FAIL(advance_status(*lease_service_, *sql_proxy_, *ls_attr_, next_status))) { } else if (OB_FAIL(advance_status(*lease_service_, *sql_proxy_, *ls_attr_, next_status))) {
LOG_WARN("[DATA_BACKUP]failed to advance task status", K(ret), K(*ls_attr_), K(next_status)); LOG_WARN("[DATA_BACKUP]failed to advance task status", K(ret), KPC(ls_attr_), K(next_status));
} else if (OB_FAIL(task_scheduler_->add_task(task))) { } else if (OB_FAIL(task_scheduler_->add_task(task))) {
LOG_WARN("[DATA_BACKUP]failed to add task", K(ret), K(*job_attr_), K(task)); LOG_WARN("[DATA_BACKUP]failed to add task", K(ret), KPC(job_attr_), K(task));
} }
return ret; return ret;
} }
@ -239,11 +239,11 @@ int ObBackupDataLSTaskMgr::gen_and_add_backup_compl_log_()
ObBackupTaskStatus next_status; ObBackupTaskStatus next_status;
next_status.status_ = ObBackupTaskStatus::Status::PENDING; next_status.status_ = ObBackupTaskStatus::Status::PENDING;
if (OB_FAIL(task.build(*job_attr_, *set_task_attr_, *ls_attr_))) { if (OB_FAIL(task.build(*job_attr_, *set_task_attr_, *ls_attr_))) {
LOG_WARN("[DATA_BACKUP]failed to build task", K(ret), K(*job_attr_), K(*set_task_attr_), K(*ls_attr_)); LOG_WARN("[DATA_BACKUP]failed to build task", K(ret), KPC(job_attr_), KPC(set_task_attr_), KPC(ls_attr_));
} else if (OB_FAIL(advance_status(*lease_service_, *sql_proxy_, *ls_attr_, next_status))) { } else if (OB_FAIL(advance_status(*lease_service_, *sql_proxy_, *ls_attr_, next_status))) {
LOG_WARN("[DATA_BACKUP]failed to advance task status", K(ret), K(*ls_attr_), K(next_status)); LOG_WARN("[DATA_BACKUP]failed to advance task status", K(ret), KPC(ls_attr_), K(next_status));
} else if (OB_FAIL(task_scheduler_->add_task(task))) { } else if (OB_FAIL(task_scheduler_->add_task(task))) {
LOG_WARN("[DATA_BACKUP]failed to add task", K(ret), K(*ls_attr_)); LOG_WARN("[DATA_BACKUP]failed to add task", K(ret), KPC(ls_attr_));
} }
return ret; return ret;
} }
@ -257,11 +257,11 @@ int ObBackupDataLSTaskMgr::gen_and_add_build_index_task_()
ObBackupTaskStatus next_status; ObBackupTaskStatus next_status;
next_status.status_ = ObBackupTaskStatus::Status::PENDING; next_status.status_ = ObBackupTaskStatus::Status::PENDING;
if (OB_FAIL(task.build(*job_attr_, *set_task_attr_, *ls_attr_))) { if (OB_FAIL(task.build(*job_attr_, *set_task_attr_, *ls_attr_))) {
LOG_WARN("[DATA_BACKUP]failed to build task", K(ret), K(*job_attr_), K(*set_task_attr_), K(*ls_attr_)); LOG_WARN("[DATA_BACKUP]failed to build task", K(ret), KPC(job_attr_), KPC(set_task_attr_), KPC(ls_attr_));
} else if (OB_FAIL(advance_status(*lease_service_, *sql_proxy_, *ls_attr_, next_status))) { } else if (OB_FAIL(advance_status(*lease_service_, *sql_proxy_, *ls_attr_, next_status))) {
LOG_WARN("[DATA_BACKUP]failed to advance task status", K(ret), K(*ls_attr_), K(next_status)); LOG_WARN("[DATA_BACKUP]failed to advance task status", K(ret), KPC(ls_attr_), K(next_status));
} else if (OB_FAIL(task_scheduler_->add_task(task))) { } else if (OB_FAIL(task_scheduler_->add_task(task))) {
LOG_WARN("[DATA_BACKUP]failed to add task", K(ret), K(*ls_attr_)); LOG_WARN("[DATA_BACKUP]failed to add task", K(ret), KPC(ls_attr_));
} }
return ret; return ret;
} }
@ -396,7 +396,7 @@ int ObBackupDataLSTaskMgr::finish_(int64_t &finish_cnt)
} else { } else {
if (OB_FAIL(redo_ls_task(*lease_service_, trans, *ls_attr_, ls_attr_->start_turn_id_, if (OB_FAIL(redo_ls_task(*lease_service_, trans, *ls_attr_, ls_attr_->start_turn_id_,
ls_attr_->turn_id_, next_retry_id))) { ls_attr_->turn_id_, next_retry_id))) {
LOG_WARN("[DATA_BACKUP]failed to redo ls task", K(ret), K(*ls_attr_)); LOG_WARN("[DATA_BACKUP]failed to redo ls task", K(ret), KPC(ls_attr_));
} }
if (OB_SUCC(ret)) { if (OB_SUCC(ret)) {
if (OB_FAIL(trans.end(true))) { if (OB_FAIL(trans.end(true))) {
@ -415,7 +415,7 @@ int ObBackupDataLSTaskMgr::finish_(int64_t &finish_cnt)
} }
} else { } else {
ret = ls_attr_->result_; ret = ls_attr_->result_;
LOG_WARN("ls task failed, backup can't not continue", K(ret), K(*ls_attr_)); LOG_WARN("ls task failed, backup can't not continue", K(ret), KPC(ls_attr_));
} }
} }
return ret; return ret;
@ -491,13 +491,13 @@ int ObBackupDataLSTaskMgr::cancel(int64_t &finish_cnt)
if (ret == OB_ENTRY_NOT_EXIST) { if (ret == OB_ENTRY_NOT_EXIST) {
ret = OB_SUCCESS; ret = OB_SUCCESS;
} else { } else {
LOG_WARN("[DATA_BACKUP]failed to cancel task", K(ret), K(*ls_attr_)); LOG_WARN("[DATA_BACKUP]failed to cancel task", K(ret), KPC(ls_attr_));
} }
} }
} }
if (OB_FAIL(ret)) { if (OB_FAIL(ret)) {
} else if (OB_FAIL(advance_status(*lease_service_, *sql_proxy_, *ls_attr_, next_status, OB_CANCELED, end_ts))) { } else if (OB_FAIL(advance_status(*lease_service_, *sql_proxy_, *ls_attr_, next_status, OB_CANCELED, end_ts))) {
LOG_WARN("[DATA_BACKUP]failed to advance status", K(ret), K(*ls_attr_), K(next_status)); LOG_WARN("[DATA_BACKUP]failed to advance status", K(ret), KPC(ls_attr_), K(next_status));
} else { } else {
++finish_cnt; ++finish_cnt;
} }

88
src/rootserver/backup/ob_backup_data_scheduler.cpp
View File

@ -153,7 +153,7 @@ int ObBackupDataScheduler::do_get_need_reload_task_(
} else if (ObBackupTaskStatus::Status::PENDING == ls_task.status_.status_ } else if (ObBackupTaskStatus::Status::PENDING == ls_task.status_.status_
|| ObBackupTaskStatus::Status::DOING == ls_task.status_.status_) { || ObBackupTaskStatus::Status::DOING == ls_task.status_.status_) {
if (OB_FAIL(tasks.push_back(task))) { if (OB_FAIL(tasks.push_back(task))) {
LOG_WARN("[DATA_BACKUP]failed to push back task", K(ret), K(*task)); LOG_WARN("[DATA_BACKUP]failed to push back task", K(ret), KPC(task));
} }
} }
} }
@ -835,7 +835,7 @@ int ObBackupDataScheduler::handle_execute_over(
LOG_WARN("[DATA_BACKUP]failed to start trans", K(ret)); LOG_WARN("[DATA_BACKUP]failed to start trans", K(ret));
} else { } else {
if (OB_FAIL(ObBackupLSTaskOperator::get_ls_task(trans, true/*for update*/, task->get_task_id(), task->get_tenant_id(), ls_id, ls_attr))) { if (OB_FAIL(ObBackupLSTaskOperator::get_ls_task(trans, true/*for update*/, task->get_task_id(), task->get_tenant_id(), ls_id, ls_attr))) {
LOG_WARN("[DATA_BACKUP]failed to get log stream task", K(ret), K(*task)); LOG_WARN("[DATA_BACKUP]failed to get log stream task", K(ret), KPC(task));
} else if (OB_FAIL(ObBackupDataLSTaskMgr::statistic_info(*lease_service_, trans, ls_attr))) { } else if (OB_FAIL(ObBackupDataLSTaskMgr::statistic_info(*lease_service_, trans, ls_attr))) {
// TODO: delete this when observer support the function that backup progress statistics // TODO: delete this when observer support the function that backup progress statistics
LOG_WARN("[DATA_BACKUP]failed to update statistic infomation of ls task", K(ret), K(ls_attr)); LOG_WARN("[DATA_BACKUP]failed to update statistic infomation of ls task", K(ret), K(ls_attr));
@ -1032,12 +1032,12 @@ int ObUserTenantBackupJobMgr::deal_non_reentrant_job(const int err)
job_attr_->end_ts_ = ObTimeUtility::current_time(); job_attr_->end_ts_ = ObTimeUtility::current_time();
bool is_exist_set_task = true; bool is_exist_set_task = true;
bool is_start = false; bool is_start = false;
LOG_INFO("start to deal non reentrant job", K(*job_attr_), KP(err)); LOG_INFO("start to deal non reentrant job", KPC(job_attr_), KP(err));
if (IS_NOT_INIT) { if (IS_NOT_INIT) {
ret = OB_INVALID_ARGUMENT; ret = OB_INVALID_ARGUMENT;
LOG_WARN("[DATA_BACKUP]not init", K(ret)); LOG_WARN("[DATA_BACKUP]not init", K(ret));
} else if (OB_FAIL(task_scheduler_->cancel_tasks(BackupJobType::BACKUP_DATA_JOB, job_attr_->job_id_, job_attr_->tenant_id_))) { } else if (OB_FAIL(task_scheduler_->cancel_tasks(BackupJobType::BACKUP_DATA_JOB, job_attr_->job_id_, job_attr_->tenant_id_))) {
LOG_WARN("[DATA_BACKUP]failed to cancel backup tasks", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to cancel backup tasks", K(ret), KPC(job_attr_));
} else if (ObBackupStatus::Status::INIT == job_attr_->status_.status_) { } else if (ObBackupStatus::Status::INIT == job_attr_->status_.status_) {
if (OB_FAIL(advance_job_status(*sql_proxy_, next_status, err, job_attr_->end_ts_))) { if (OB_FAIL(advance_job_status(*sql_proxy_, next_status, err, job_attr_->end_ts_))) {
LOG_WARN("[DATA_BACKUP]failed to move job status to FAILED", K(ret), KPC(job_attr_)); LOG_WARN("[DATA_BACKUP]failed to move job status to FAILED", K(ret), KPC(job_attr_));
@ -1056,7 +1056,7 @@ int ObUserTenantBackupJobMgr::deal_non_reentrant_job(const int err)
if (OB_FAIL(set_task_mgr.deal_failed_set_task(trans))) { if (OB_FAIL(set_task_mgr.deal_failed_set_task(trans))) {
LOG_WARN("[DATA_BACKUP]failed to deal failed set task", K(ret)); LOG_WARN("[DATA_BACKUP]failed to deal failed set task", K(ret));
} else if (OB_FAIL(advance_job_status(trans, next_status, err, job_attr_->end_ts_))) { } else if (OB_FAIL(advance_job_status(trans, next_status, err, job_attr_->end_ts_))) {
LOG_WARN("[DATA_BACKUP]failed to move job status to FAILED", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to move job status to FAILED", K(ret), KPC(job_attr_));
} }
if (OB_SUCC(ret)) { if (OB_SUCC(ret)) {
if (OB_FAIL(trans.end(true))) { if (OB_FAIL(trans.end(true))) {
@ -1096,13 +1096,13 @@ int ObUserTenantBackupJobMgr::process()
if (OB_FAIL(check_dest_validity_())) { if (OB_FAIL(check_dest_validity_())) {
LOG_WARN("[DATA_BACKUP]fail to check dest validity", K(ret)); LOG_WARN("[DATA_BACKUP]fail to check dest validity", K(ret));
} else if (OB_FAIL(persist_set_task_())) { } else if (OB_FAIL(persist_set_task_())) {
LOG_WARN("[DATA_BACKUP]failed to persist log stream task", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to persist log stream task", K(ret), KPC(job_attr_));
} }
break; break;
} }
case ObBackupStatus::Status::DOING: { case ObBackupStatus::Status::DOING: {
if (OB_FAIL(do_set_task_())) { if (OB_FAIL(do_set_task_())) {
LOG_WARN("[DATA_BACKUP]failed to backup data", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to backup data", K(ret), KPC(job_attr_));
} }
break; break;
} }
@ -1110,19 +1110,19 @@ int ObUserTenantBackupJobMgr::process()
case ObBackupStatus::Status::FAILED: case ObBackupStatus::Status::FAILED:
case ObBackupStatus::Status::CANCELED: { case ObBackupStatus::Status::CANCELED: {
if (OB_FAIL(move_to_history_())) { if (OB_FAIL(move_to_history_())) {
LOG_WARN("[DATA_BACKUP]failed to move job and set to histroy", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to move job and set to histroy", K(ret), KPC(job_attr_));
} }
break; break;
} }
case ObBackupStatus::Status::CANCELING: { case ObBackupStatus::Status::CANCELING: {
if (OB_FAIL(cancel_())) { if (OB_FAIL(cancel_())) {
LOG_WARN("[DATA_BACKUP]failed to cancel backup", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to cancel backup", K(ret), KPC(job_attr_));
} }
break; break;
} }
default: { default: {
ret = OB_ERR_SYS; ret = OB_ERR_SYS;
LOG_ERROR("[DATA_BACKUP]unknown backup status", K(ret), K(*job_attr_)); LOG_ERROR("[DATA_BACKUP]unknown backup status", K(ret), KPC(job_attr_));
} }
} }
} }
@ -1158,7 +1158,7 @@ int ObUserTenantBackupJobMgr::move_to_history_()
ObMySQLTransaction trans; ObMySQLTransaction trans;
ObBackupSetTaskMgr set_task_mgr; ObBackupSetTaskMgr set_task_mgr;
if (is_sys_tenant(job_attr_->initiator_tenant_id_) && OB_FAIL(report_failed_to_initiator_())) { if (is_sys_tenant(job_attr_->initiator_tenant_id_) && OB_FAIL(report_failed_to_initiator_())) {
LOG_WARN("fail to report job finish to initiator tenant id", K(ret), K(*job_attr_)); LOG_WARN("fail to report job finish to initiator tenant id", K(ret), KPC(job_attr_));
} else if (OB_FAIL(trans.start(sql_proxy_, tenant_id_))) { } else if (OB_FAIL(trans.start(sql_proxy_, tenant_id_))) {
LOG_WARN("[DATA_BACKUP]failed to start trans", K(ret)); LOG_WARN("[DATA_BACKUP]failed to start trans", K(ret));
} else { } else {
@ -1167,7 +1167,7 @@ int ObUserTenantBackupJobMgr::move_to_history_()
if (OB_ENTRY_NOT_EXIST == ret) { // when job was canceled in INIT STATUS, there are no set task in task table. if (OB_ENTRY_NOT_EXIST == ret) { // when job was canceled in INIT STATUS, there are no set task in task table.
ret = OB_SUCCESS; ret = OB_SUCCESS;
} else { } else {
LOG_WARN("[DATA_BACKUP]failed to init set task mgr", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to init set task mgr", K(ret), KPC(job_attr_));
} }
} else if (OB_FAIL(set_task_mgr.do_clean_up(trans))) { } else if (OB_FAIL(set_task_mgr.do_clean_up(trans))) {
LOG_WARN("[DATA_BACKUP]failed to do clean up", K(ret), K(set_task_mgr)); LOG_WARN("[DATA_BACKUP]failed to do clean up", K(ret), K(set_task_mgr));
@ -1175,7 +1175,7 @@ int ObUserTenantBackupJobMgr::move_to_history_()
if (OB_FAIL(ret)) { if (OB_FAIL(ret)) {
} else if (OB_FAIL(ObBackupJobOperator::move_job_to_his(trans, job_attr_->tenant_id_, job_attr_->job_id_))) { } else if (OB_FAIL(ObBackupJobOperator::move_job_to_his(trans, job_attr_->tenant_id_, job_attr_->job_id_))) {
LOG_WARN("[DATA_BACKUP]failed to move job to history", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to move job to history", K(ret), KPC(job_attr_));
} }
if (OB_SUCC(ret)) { if (OB_SUCC(ret)) {
@ -1255,7 +1255,7 @@ int ObUserTenantBackupJobMgr::cancel_()
int ret = OB_SUCCESS; int ret = OB_SUCCESS;
ObBackupSetTaskMgr set_task_mgr; ObBackupSetTaskMgr set_task_mgr;
if (OB_FAIL(check_can_backup_())) { if (OB_FAIL(check_can_backup_())) {
LOG_WARN("[DATA_BACKUP]failed to check can backup", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to check can backup", K(ret), KPC(job_attr_));
} else if (OB_FAIL(update_set_task_to_canceling_())) { } else if (OB_FAIL(update_set_task_to_canceling_())) {
LOG_WARN("[DATA_BACKUP]failed to update set task to canceling", K(ret)); LOG_WARN("[DATA_BACKUP]failed to update set task to canceling", K(ret));
} else { } else {
@ -1266,7 +1266,7 @@ int ObUserTenantBackupJobMgr::cancel_()
is_set_task_exist = false; is_set_task_exist = false;
ret = OB_SUCCESS; ret = OB_SUCCESS;
} else { } else {
LOG_WARN("[DATA_BACKUP]failed to init set task mgr", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to init set task mgr", K(ret), KPC(job_attr_));
} }
} else if (OB_FAIL(set_task_mgr.process())) { } else if (OB_FAIL(set_task_mgr.process())) {
LOG_WARN("[DATA_BACKUP]failed to persist ls task", K(ret), K(set_task_mgr)); LOG_WARN("[DATA_BACKUP]failed to persist ls task", K(ret), K(set_task_mgr));
@ -1279,7 +1279,7 @@ int ObUserTenantBackupJobMgr::cancel_()
if (OB_FAIL(advance_job_status(*sql_proxy_, next_status, OB_CANCELED, job_attr_->end_ts_))) { if (OB_FAIL(advance_job_status(*sql_proxy_, next_status, OB_CANCELED, job_attr_->end_ts_))) {
LOG_WARN("[DATA_BACKUP]failed to advance_job_status", K(ret)); LOG_WARN("[DATA_BACKUP]failed to advance_job_status", K(ret));
} else { } else {
LOG_INFO("succeed to cancel job, advance job status to CANCELED", K(*job_attr_)); LOG_INFO("succeed to cancel job, advance job status to CANCELED", KPC(job_attr_));
} }
} }
} }
@ -1313,7 +1313,7 @@ int ObUserTenantBackupJobMgr::update_set_task_to_canceling_()
ret = OB_ERR_UNEXPECTED; ret = OB_ERR_UNEXPECTED;
LOG_ERROR("[DATA_BACKUP]invalid affected_rows", K(ret), K(affected_rows), K(sql), K(next_status)); LOG_ERROR("[DATA_BACKUP]invalid affected_rows", K(ret), K(affected_rows), K(sql), K(next_status));
} else { } else {
LOG_INFO("[DATA_BACKUP]advance set task status", K(*job_attr_), K(next_status), K(sql)); LOG_INFO("[DATA_BACKUP]advance set task status", KPC(job_attr_), K(next_status), K(sql));
} }
return ret; return ret;
} }
@ -1323,7 +1323,7 @@ int ObUserTenantBackupJobMgr::do_set_task_()
int ret = OB_SUCCESS; int ret = OB_SUCCESS;
LOG_INFO("job is in doing backup set task", KPC(job_attr_)); LOG_INFO("job is in doing backup set task", KPC(job_attr_));
if (OB_FAIL(check_can_backup_())) { if (OB_FAIL(check_can_backup_())) {
LOG_WARN("[DATA_BACKUP]failed to check can backup", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to check can backup", K(ret), KPC(job_attr_));
} else { } else {
ObBackupStatus next_status; ObBackupStatus next_status;
ObBackupSetTaskMgr set_task_mgr; ObBackupSetTaskMgr set_task_mgr;
@ -1337,7 +1337,7 @@ int ObUserTenantBackupJobMgr::do_set_task_()
|| ObBackupStatus::Status::FAILED == next_status.status_) { || ObBackupStatus::Status::FAILED == next_status.status_) {
job_attr_->end_ts_ = ObTimeUtility::current_time(); job_attr_->end_ts_ = ObTimeUtility::current_time();
if (OB_FAIL(advance_job_status(*sql_proxy_, next_status, job_attr_->result_, job_attr_->end_ts_))) { if (OB_FAIL(advance_job_status(*sql_proxy_, next_status, job_attr_->result_, job_attr_->end_ts_))) {
LOG_WARN("[DATA_BACKUP]failed to advance status", K(ret), K(next_status), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to advance status", K(ret), K(next_status), KPC(job_attr_));
} else { } else {
LOG_INFO("[DATA_BACKUP]succeed doing backup set task, and advancing job status to next status", LOG_INFO("[DATA_BACKUP]succeed doing backup set task, and advancing job status to next status",
K(next_status), "tenant_id", job_attr_->tenant_id_, "job_id", job_attr_->job_id_); K(next_status), "tenant_id", job_attr_->tenant_id_, "job_id", job_attr_->job_id_);
@ -1354,15 +1354,15 @@ int ObUserTenantBackupJobMgr::persist_set_task_()
ObMySQLTransaction trans; ObMySQLTransaction trans;
LOG_INFO("start to persist set task", KPC(job_attr_)); LOG_INFO("start to persist set task", KPC(job_attr_));
if (OB_FAIL(check_can_backup_())) { if (OB_FAIL(check_can_backup_())) {
LOG_WARN("[DATA_BACKUP]failed to check can backup", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to check can backup", K(ret), KPC(job_attr_));
} else if (OB_FAIL(trans.start(sql_proxy_, tenant_id_))) { } else if (OB_FAIL(trans.start(sql_proxy_, tenant_id_))) {
LOG_WARN("[DATA_BACKUP]failed to start trans", K(ret)); LOG_WARN("[DATA_BACKUP]failed to start trans", K(ret));
} else { } else {
ObBackupStatus next_status(ObBackupStatus::Status::DOING); ObBackupStatus next_status(ObBackupStatus::Status::DOING);
if (OB_FAIL(insert_backup_set_task_(trans))) { if (OB_FAIL(insert_backup_set_task_(trans))) {
LOG_WARN("[DATA_BACKUP]failed to insert backup set task", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to insert backup set task", K(ret), KPC(job_attr_));
} else if (OB_FAIL(insert_backup_set_file_(trans))) { } else if (OB_FAIL(insert_backup_set_file_(trans))) {
LOG_WARN("[DATA_BACKUP]failed to insert backup set file", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to insert backup set file", K(ret), KPC(job_attr_));
} else if (OB_FAIL(advance_job_status(trans, next_status))) { } else if (OB_FAIL(advance_job_status(trans, next_status))) {
LOG_WARN("fail to advance job status to doing", K(ret), KPC(job_attr_)); LOG_WARN("fail to advance job status to doing", K(ret), KPC(job_attr_));
} }
@ -1398,9 +1398,9 @@ int ObUserTenantBackupJobMgr::insert_backup_set_task_(common::ObISQLClient &sql_
int ret = OB_SUCCESS; int ret = OB_SUCCESS;
ObBackupSetTaskAttr backup_set_task; ObBackupSetTaskAttr backup_set_task;
if (OB_FAIL(backup_set_task.passwd_.assign(job_attr_->passwd_))) { if (OB_FAIL(backup_set_task.passwd_.assign(job_attr_->passwd_))) {
LOG_WARN("[DATA_BACKUP]failed to assign passwd", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to assign passwd", K(ret), KPC(job_attr_));
} else if (OB_FAIL(backup_set_task.backup_path_.assign(job_attr_->backup_path_))) { } else if (OB_FAIL(backup_set_task.backup_path_.assign(job_attr_->backup_path_))) {
LOG_WARN("[DATA_BACKUP]failed to assign backup dest", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to assign backup dest", K(ret), KPC(job_attr_));
} else if (OB_FAIL(get_next_task_id_(sql_proxy, backup_set_task.task_id_))) { } else if (OB_FAIL(get_next_task_id_(sql_proxy, backup_set_task.task_id_))) {
LOG_WARN("[DATA_BACKUP]failed to get next task id", K(ret)); LOG_WARN("[DATA_BACKUP]failed to get next task id", K(ret));
} else if (OB_FAIL(ObBackupDataScheduler::get_scn(sql_proxy, job_attr_->tenant_id_, backup_set_task.start_scn_))) { } else if (OB_FAIL(ObBackupDataScheduler::get_scn(sql_proxy, job_attr_->tenant_id_, backup_set_task.start_scn_))) {
@ -1438,17 +1438,17 @@ int ObUserTenantBackupJobMgr::insert_backup_set_file_(common::ObISQLClient &sql_
ObBackupDest backup_dest; ObBackupDest backup_dest;
if (OB_FAIL(ObBackupSetFileOperator::get_prev_backup_set_id(sql_proxy, job_attr_->tenant_id_, job_attr_->backup_set_id_, if (OB_FAIL(ObBackupSetFileOperator::get_prev_backup_set_id(sql_proxy, job_attr_->tenant_id_, job_attr_->backup_set_id_,
job_attr_->backup_type_, job_attr_->backup_path_, prev_full_backup_set_id, prev_inc_backup_set_id))) { job_attr_->backup_type_, job_attr_->backup_path_, prev_full_backup_set_id, prev_inc_backup_set_id))) {
LOG_WARN("[DATA_BACKUP]fail to get prev backup set id", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]fail to get prev backup set id", K(ret), KPC(job_attr_));
} else if (OB_FAIL(ObBackupStorageInfoOperator::get_backup_dest(sql_proxy, job_attr_->tenant_id_, job_attr_->backup_path_, backup_dest))) { } else if (OB_FAIL(ObBackupStorageInfoOperator::get_backup_dest(sql_proxy, job_attr_->tenant_id_, job_attr_->backup_path_, backup_dest))) {
LOG_WARN("[DATA_BACKUP]fail to get backup dest", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]fail to get backup dest", K(ret), KPC(job_attr_));
} else if (OB_FAIL(ObBackupStorageInfoOperator::get_dest_id(sql_proxy, job_attr_->tenant_id_, backup_dest, dest_id))) { } else if (OB_FAIL(ObBackupStorageInfoOperator::get_dest_id(sql_proxy, job_attr_->tenant_id_, backup_dest, dest_id))) {
LOG_WARN("[DATA_BACKUP]fail to get dest id", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]fail to get dest id", K(ret), KPC(job_attr_));
} else if (OB_FAIL(fill_backup_set_desc_(*job_attr_, prev_full_backup_set_id, prev_inc_backup_set_id, dest_id, backup_set_desc))) { } else if (OB_FAIL(fill_backup_set_desc_(*job_attr_, prev_full_backup_set_id, prev_inc_backup_set_id, dest_id, backup_set_desc))) {
LOG_WARN("[DATA_BACKUP]fail to fill backup set desc", K(ret), K(*job_attr_), K(prev_full_backup_set_id), K(prev_inc_backup_set_id)); LOG_WARN("[DATA_BACKUP]fail to fill backup set desc", K(ret), KPC(job_attr_), K(prev_full_backup_set_id), K(prev_inc_backup_set_id));
} else if (OB_FAIL(lease_service_->check_lease())) { } else if (OB_FAIL(lease_service_->check_lease())) {
LOG_WARN("fail to check leader", K(ret)); LOG_WARN("fail to check leader", K(ret));
} else if (OB_FAIL(ObBackupSetFileOperator::insert_backup_set_file(sql_proxy, backup_set_desc))) { } else if (OB_FAIL(ObBackupSetFileOperator::insert_backup_set_file(sql_proxy, backup_set_desc))) {
LOG_WARN("[DATA_BACKUP]fail to insert backup set file", K(ret), K(backup_set_desc), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]fail to insert backup set file", K(ret), K(backup_set_desc), KPC(job_attr_));
} }
return ret; return ret;
} }
@ -1517,7 +1517,7 @@ int ObUserTenantBackupJobMgr::advance_job_status(
if (OB_FAIL(lease_service_->check_lease())) { if (OB_FAIL(lease_service_->check_lease())) {
LOG_WARN("fail to check leader", K(ret)); LOG_WARN("fail to check leader", K(ret));
} else if (OB_FAIL(ObBackupJobOperator::advance_job_status(trans, *job_attr_, next_status, result, end_ts))) { } else if (OB_FAIL(ObBackupJobOperator::advance_job_status(trans, *job_attr_, next_status, result, end_ts))) {
LOG_WARN("[DATA_BACKUP]failed to advance job status", K(ret), K(*job_attr_), K(next_status), K(result), K(end_ts)); LOG_WARN("[DATA_BACKUP]failed to advance job status", K(ret), KPC(job_attr_), K(next_status), K(result), K(end_ts));
} }
return ret; return ret;
} }
@ -1543,7 +1543,7 @@ int ObSysTenantBackupJobMgr::process()
} }
case ObBackupStatus::Status::DOING: { case ObBackupStatus::Status::DOING: {
if (OB_FAIL(statistic_user_tenant_job_())) { if (OB_FAIL(statistic_user_tenant_job_())) {
LOG_WARN("[DATA_BACKUP]failed to backup data", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to backup data", K(ret), KPC(job_attr_));
} }
break; break;
} }
@ -1551,19 +1551,19 @@ int ObSysTenantBackupJobMgr::process()
case ObBackupStatus::Status::FAILED: case ObBackupStatus::Status::FAILED:
case ObBackupStatus::Status::CANCELED: { case ObBackupStatus::Status::CANCELED: {
if (OB_FAIL(move_to_history_())) { if (OB_FAIL(move_to_history_())) {
LOG_WARN("[DATA_BACKUP]failed to move job to histroy", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to move job to histroy", K(ret), KPC(job_attr_));
} }
break; break;
} }
case ObBackupStatus::Status::CANCELING: { case ObBackupStatus::Status::CANCELING: {
if (OB_FAIL(cancel_user_tenant_job_())) { if (OB_FAIL(cancel_user_tenant_job_())) {
LOG_WARN("[DATA_BACKUP]failed to cancel backup job", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to cancel backup job", K(ret), KPC(job_attr_));
} }
break; break;
} }
default: { default: {
ret = OB_ERR_SYS; ret = OB_ERR_SYS;
LOG_ERROR("[DATA_BACKUP]unknown backup status", K(ret), K(*job_attr_)); LOG_ERROR("[DATA_BACKUP]unknown backup status", K(ret), KPC(job_attr_));
} }
} }
} }
@ -1600,10 +1600,10 @@ int ObSysTenantBackupJobMgr::handle_user_tenant_backupdatabase_()
if (OB_SUCC(ret)) { if (OB_SUCC(ret)) {
ObBackupStatus next_status(ObBackupStatus::Status::DOING); ObBackupStatus next_status(ObBackupStatus::Status::DOING);
if (OB_FAIL(advance_status_(*sql_proxy_, next_status))) { if (OB_FAIL(advance_status_(*sql_proxy_, next_status))) {
LOG_WARN("fail to advance sys job status", K(ret), K(*job_attr_), K(next_status)); LOG_WARN("fail to advance sys job status", K(ret), KPC(job_attr_), K(next_status));
} else { } else {
backup_service_->wakeup(); backup_service_->wakeup();
LOG_INFO("succeed handle user tenant backupdatabase, advance sys job to DOING", K(*job_attr_), K(next_status)); LOG_INFO("succeed handle user tenant backupdatabase, advance sys job to DOING", KPC(job_attr_), K(next_status));
} }
} }
return ret; return ret;
@ -1654,7 +1654,7 @@ int ObSysTenantBackupJobMgr::statistic_user_tenant_job_()
bool is_valid = false; bool is_valid = false;
int64_t finish_user_backup_job = 0; int64_t finish_user_backup_job = 0;
ObBackupJobAttr tmp_job_attr; ObBackupJobAttr tmp_job_attr;
LOG_INFO("sys tenant start to statistic user tenant job", K(*job_attr_)); LOG_INFO("sys tenant start to statistic user tenant job", KPC(job_attr_));
for (int64_t i = 0; OB_SUCC(ret) && i < job_attr_->executor_tenant_id_.count(); ++i) { for (int64_t i = 0; OB_SUCC(ret) && i < job_attr_->executor_tenant_id_.count(); ++i) {
const uint64_t user_tenant_id = job_attr_->executor_tenant_id_.at(i); const uint64_t user_tenant_id = job_attr_->executor_tenant_id_.at(i);
is_valid = false; is_valid = false;
@ -1690,9 +1690,9 @@ int ObSysTenantBackupJobMgr::statistic_user_tenant_job_()
} }
if (OB_SUCC(ret)) { if (OB_SUCC(ret)) {
if (OB_FAIL(advance_status_(*sql_proxy_, next_status, tmp_job_attr.result_, ObTimeUtility::current_time()))) { if (OB_FAIL(advance_status_(*sql_proxy_, next_status, tmp_job_attr.result_, ObTimeUtility::current_time()))) {
LOG_WARN("fail to advance sys job status", K(ret), K(*job_attr_), K(next_status)); LOG_WARN("fail to advance sys job status", K(ret), KPC(job_attr_), K(next_status));
} else { } else {
LOG_INFO("[DATA_BACKUP]user job finished, sys job move to next status", K(next_status), K(*job_attr_)); LOG_INFO("[DATA_BACKUP]user job finished, sys job move to next status", K(next_status), KPC(job_attr_));
} }
} }
} }
@ -1705,9 +1705,9 @@ int ObSysTenantBackupJobMgr::move_to_history_()
if (OB_FAIL(lease_service_->check_lease())) { if (OB_FAIL(lease_service_->check_lease())) {
LOG_WARN("fail to check leader", K(ret)); LOG_WARN("fail to check leader", K(ret));
} else if (OB_FAIL(ObBackupJobOperator::move_job_to_his(*sql_proxy_, job_attr_->tenant_id_, job_attr_->job_id_))) { } else if (OB_FAIL(ObBackupJobOperator::move_job_to_his(*sql_proxy_, job_attr_->tenant_id_, job_attr_->job_id_))) {
LOG_WARN("[DATA_BACKUP]failed to move job to history table", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to move job to history table", K(ret), KPC(job_attr_));
} else { } else {
LOG_INFO("sys tenant backup job succeed move to history table", K(*job_attr_)); LOG_INFO("sys tenant backup job succeed move to history table", KPC(job_attr_));
} }
return ret; return ret;
} }
@ -1752,9 +1752,9 @@ int ObSysTenantBackupJobMgr::cancel_user_tenant_job_()
ObBackupStatus next_status(ObBackupStatus::Status::CANCELED); ObBackupStatus next_status(ObBackupStatus::Status::CANCELED);
if (OB_SUCC(ret)) { if (OB_SUCC(ret)) {
if (OB_FAIL(advance_status_(*sql_proxy_, next_status, OB_CANCELED, ObTimeUtility::current_time()))) { if (OB_FAIL(advance_status_(*sql_proxy_, next_status, OB_CANCELED, ObTimeUtility::current_time()))) {
LOG_WARN("fail to advance sys job status", K(ret), K(*job_attr_), K(next_status)); LOG_WARN("fail to advance sys job status", K(ret), KPC(job_attr_), K(next_status));
} else { } else {
FLOG_INFO("[DATA_BACKUP]succeed schedule sys backup job", K(*job_attr_)); FLOG_INFO("[DATA_BACKUP]succeed schedule sys backup job", KPC(job_attr_));
} }
} }
} }
@ -1771,7 +1771,7 @@ int ObSysTenantBackupJobMgr::advance_status_(
if (OB_FAIL(lease_service_->check_lease())) { if (OB_FAIL(lease_service_->check_lease())) {
LOG_WARN("fail to check leader", K(ret)); LOG_WARN("fail to check leader", K(ret));
} else if (OB_FAIL(ObBackupJobOperator::advance_job_status(sql_proxy, *job_attr_, next_status, result, end_ts))) { } else if (OB_FAIL(ObBackupJobOperator::advance_job_status(sql_proxy, *job_attr_, next_status, result, end_ts))) {
LOG_WARN("[DATA_BACKUP]failed to advance job status", K(ret), K(*job_attr_), K(next_status), K(result), K(end_ts)); LOG_WARN("[DATA_BACKUP]failed to advance job status", K(ret), KPC(job_attr_), K(next_status), K(result), K(end_ts));
} }
return ret; return ret;
} }

38
src/rootserver/backup/ob_backup_data_set_task_mgr.cpp
View File

@ -85,7 +85,7 @@ int ObBackupSetTaskMgr::init(
desc.backup_type_ = job_attr.backup_type_; desc.backup_type_ = job_attr.backup_type_;
if (OB_FAIL(ObBackupStorageInfoOperator::get_backup_dest(sql_proxy, job_attr.tenant_id_, if (OB_FAIL(ObBackupStorageInfoOperator::get_backup_dest(sql_proxy, job_attr.tenant_id_,
job_attr.backup_path_, backup_dest))) { job_attr.backup_path_, backup_dest))) {
LOG_WARN("fail to get backup dest", K(ret), K(*job_attr_)); LOG_WARN("fail to get backup dest", K(ret), K(job_attr));
} else if (OB_FAIL(store_.init(backup_dest, desc))) { } else if (OB_FAIL(store_.init(backup_dest, desc))) {
LOG_WARN("fail to init backup data store", K(ret)); LOG_WARN("fail to init backup data store", K(ret));
} }
@ -198,7 +198,7 @@ int ObBackupSetTaskMgr::persist_sys_ls_task_()
if (OB_FAIL(ret)) { if (OB_FAIL(ret)) {
} else if (OB_FAIL(write_backup_set_placeholder(true/*start*/))) { } else if (OB_FAIL(write_backup_set_placeholder(true/*start*/))) {
LOG_WARN("fail to write backup set start placeholder", K(ret), K(*job_attr_)); LOG_WARN("fail to write backup set start placeholder", K(ret), KPC(job_attr_));
} else if (OB_FAIL(trans_.start(sql_proxy_, meta_tenant_id_))) { } else if (OB_FAIL(trans_.start(sql_proxy_, meta_tenant_id_))) {
LOG_WARN("fail to start trans", K(ret), K(meta_tenant_id_)); LOG_WARN("fail to start trans", K(ret), K(meta_tenant_id_));
} else { } else {
@ -357,7 +357,7 @@ int ObBackupSetTaskMgr::backup_sys_meta_()
} else { } else {
share::ObBackupDataTaskType type(share::ObBackupDataTaskType::Type::BACKUP_META); share::ObBackupDataTaskType type(share::ObBackupDataTaskType::Type::BACKUP_META);
if (OB_FAIL(generate_ls_tasks_(ls_ids, type))) { if (OB_FAIL(generate_ls_tasks_(ls_ids, type))) {
LOG_WARN("failed to generate log stream tasks", K(ret), K(*job_attr_), K(ls_ids)); LOG_WARN("failed to generate log stream tasks", K(ret), KPC(job_attr_), K(ls_ids));
} else if (OB_FAIL(advance_status_(trans_, next_status_))) { } else if (OB_FAIL(advance_status_(trans_, next_status_))) {
LOG_WARN("fail to advance status", K(ret), K(next_status_)); LOG_WARN("fail to advance status", K(ret), K(next_status_));
} }
@ -475,7 +475,7 @@ int ObBackupSetTaskMgr::change_meta_turn_()
LOG_WARN("fail to delete ls task", K(ret), "tenant_id", set_task_attr_.tenant_id_, "job_id", LOG_WARN("fail to delete ls task", K(ret), "tenant_id", set_task_attr_.tenant_id_, "job_id",
set_task_attr_.job_id_); set_task_attr_.job_id_);
} else if (OB_FAIL(generate_ls_tasks_(ls_ids, type))) { } else if (OB_FAIL(generate_ls_tasks_(ls_ids, type))) {
LOG_WARN("failed to generate log stream tasks", K(ret), K(*job_attr_), K(ls_ids)); LOG_WARN("failed to generate log stream tasks", K(ret), KPC(job_attr_), K(ls_ids));
} else if (OB_FAIL(ObBackupTaskOperator::update_meta_turn_id(trans_, set_task_attr_.task_id_, } else if (OB_FAIL(ObBackupTaskOperator::update_meta_turn_id(trans_, set_task_attr_.task_id_,
set_task_attr_.tenant_id_, next_meta_turn_id))) { set_task_attr_.tenant_id_, next_meta_turn_id))) {
LOG_WARN("fail to update meta turn id", K(ret), K(set_task_attr_)); LOG_WARN("fail to update meta turn id", K(ret), K(set_task_attr_));
@ -508,7 +508,7 @@ int ObBackupSetTaskMgr::merge_ls_meta_infos_(const ObIArray<share::ObBackupLSTas
ObBackupLSMetaInfosDesc ls_meta_infos; ObBackupLSMetaInfosDesc ls_meta_infos;
if (OB_FAIL(ObBackupStorageInfoOperator::get_backup_dest(*sql_proxy_, job_attr_->tenant_id_, if (OB_FAIL(ObBackupStorageInfoOperator::get_backup_dest(*sql_proxy_, job_attr_->tenant_id_,
job_attr_->backup_path_, backup_dest))) { job_attr_->backup_path_, backup_dest))) {
LOG_WARN("fail to get backup dest", K(ret), K(*job_attr_)); LOG_WARN("fail to get backup dest", K(ret), KPC(job_attr_));
} else { } else {
ARRAY_FOREACH_X(ls_tasks, i, cnt, OB_SUCC(ret)) { ARRAY_FOREACH_X(ls_tasks, i, cnt, OB_SUCC(ret)) {
const ObBackupLSTaskAttr &ls_task_attr = ls_tasks.at(i); const ObBackupLSTaskAttr &ls_task_attr = ls_tasks.at(i);
@ -868,7 +868,7 @@ int ObBackupSetTaskMgr::backup_data_()
if (OB_FAIL(ObBackupDataScheduler::get_scn(*sql_proxy_, job_attr_->tenant_id_, end_scn))) { if (OB_FAIL(ObBackupDataScheduler::get_scn(*sql_proxy_, job_attr_->tenant_id_, end_scn))) {
LOG_WARN("[DATA_BACKUP]failed to get end ts", K(ret), "tenant_id", job_attr_->tenant_id_); LOG_WARN("[DATA_BACKUP]failed to get end ts", K(ret), "tenant_id", job_attr_->tenant_id_);
} else if (OB_FAIL(build_index_(build_index_attr, set_task_attr_.data_turn_id_, set_task_attr_.task_id_, finish_build_index))) { } else if (OB_FAIL(build_index_(build_index_attr, set_task_attr_.data_turn_id_, set_task_attr_.task_id_, finish_build_index))) {
LOG_WARN("[DATA_BACKUP]failed to wait build index", K(ret), K(set_task_attr_), K(*build_index_attr)); LOG_WARN("[DATA_BACKUP]failed to wait build index", K(ret), K(set_task_attr_), KPC(build_index_attr));
} else if (!finish_build_index) { } else if (!finish_build_index) {
} else if (OB_FAIL(check_change_task_turn_(ls_task, need_change_turn, tablets_to_ls, new_ls_array))) { } else if (OB_FAIL(check_change_task_turn_(ls_task, need_change_turn, tablets_to_ls, new_ls_array))) {
LOG_WARN("[DATA_BACKUP]failed to check change task turn", K(ret), K(set_task_attr_)); LOG_WARN("[DATA_BACKUP]failed to check change task turn", K(ret), K(set_task_attr_));
@ -996,7 +996,7 @@ int ObBackupSetTaskMgr::update_inner_task_(
// TODO use another error code to determine change turn in 4.1 // TODO use another error code to determine change turn in 4.1
} else if (OB_FAIL(ObBackupDataLSTaskMgr::redo_ls_task( } else if (OB_FAIL(ObBackupDataLSTaskMgr::redo_ls_task(
*lease_service_, trans_, *ls_attr, ls_attr->start_turn_id_, set_task_attr_.data_turn_id_, 0/*retry_id*/))) { *lease_service_, trans_, *ls_attr, ls_attr->start_turn_id_, set_task_attr_.data_turn_id_, 0/*retry_id*/))) {
LOG_WARN("[DATA_BACKUP]failed to update ls task result to success", K(ret), K(*ls_attr)); LOG_WARN("[DATA_BACKUP]failed to update ls task result to success", K(ret), KPC(ls_attr));
} }
} }
ObBackupDataTaskType type; ObBackupDataTaskType type;
@ -1076,7 +1076,7 @@ int ObBackupSetTaskMgr::build_index_(
} }
} else { } else {
ret = OB_ERR_UNEXPECTED; ret = OB_ERR_UNEXPECTED;
LOG_WARN("[DATA_BACKUP]unexpected err", K(ret), K(*build_index_attr)); LOG_WARN("[DATA_BACKUP]unexpected err", K(ret), KPC(build_index_attr));
} }
return ret; return ret;
} }
@ -1503,15 +1503,15 @@ int ObBackupSetTaskMgr::write_extern_infos()
(ObExternBackupSetInfoDesc, backup_set_info)) { (ObExternBackupSetInfoDesc, backup_set_info)) {
if (OB_FAIL(ret)) { if (OB_FAIL(ret)) {
} else if (OB_FAIL(write_extern_locality_info_(locality_info))) { } else if (OB_FAIL(write_extern_locality_info_(locality_info))) {
LOG_WARN("[DATA_BACKUP]failed to write extern tenant locality info", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to write extern tenant locality info", K(ret), KPC(job_attr_));
} else if (OB_FAIL(write_backup_set_info_(set_task_attr_, backup_set_info))) { } else if (OB_FAIL(write_backup_set_info_(set_task_attr_, backup_set_info))) {
LOG_WARN("[DATA_BACKUP]failed to write backup set info", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to write backup set info", K(ret), KPC(job_attr_));
} else if (OB_FAIL(write_tenant_backup_set_infos_())) { } else if (OB_FAIL(write_tenant_backup_set_infos_())) {
LOG_WARN("[DATA_BACKUP]failed to write tenant backup set infos", K(ret)); LOG_WARN("[DATA_BACKUP]failed to write tenant backup set infos", K(ret));
} else if (OB_FAIL(write_extern_diagnose_info_(locality_info, backup_set_info))) { // } else if (OB_FAIL(write_extern_diagnose_info_(locality_info, backup_set_info))) { //
LOG_WARN("[DATA_BACKUP]failed to write extern tenant diagnose info", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to write extern tenant diagnose info", K(ret), KPC(job_attr_));
} else if (OB_FAIL(write_backup_set_placeholder(false/*finish job*/))) { } else if (OB_FAIL(write_backup_set_placeholder(false/*finish job*/))) {
LOG_WARN("[DATA_BACKUP]failed to write backup set finish placeholder", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to write backup set finish placeholder", K(ret), KPC(job_attr_));
} }
} }
return ret; return ret;
@ -1527,12 +1527,12 @@ int ObBackupSetTaskMgr::write_backup_set_info_(
ObBackupSetFileDesc &backup_set_file = backup_set_info.backup_set_file_; ObBackupSetFileDesc &backup_set_file = backup_set_info.backup_set_file_;
ObBackupDest backup_dest; ObBackupDest backup_dest;
if (OB_FAIL(ObBackupStorageInfoOperator::get_backup_dest(*sql_proxy_, job_attr_->tenant_id_, set_task_attr.backup_path_, backup_dest))) { if (OB_FAIL(ObBackupStorageInfoOperator::get_backup_dest(*sql_proxy_, job_attr_->tenant_id_, set_task_attr.backup_path_, backup_dest))) {
LOG_WARN("[DATA_BACKUP]fail to get backup dest", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]fail to get backup dest", K(ret), KPC(job_attr_));
} else if (OB_FAIL(ObBackupStorageInfoOperator::get_dest_id(*sql_proxy_, job_attr_->tenant_id_, backup_dest, dest_id))) { } else if (OB_FAIL(ObBackupStorageInfoOperator::get_dest_id(*sql_proxy_, job_attr_->tenant_id_, backup_dest, dest_id))) {
LOG_WARN("[DATA_BACKUP]failed to get dest id", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to get dest id", K(ret), KPC(job_attr_));
} else if (OB_FAIL(ObBackupSetFileOperator::get_backup_set_file(*sql_proxy_, false/*for update*/, job_attr_->backup_set_id_, job_attr_->incarnation_id_, } else if (OB_FAIL(ObBackupSetFileOperator::get_backup_set_file(*sql_proxy_, false/*for update*/, job_attr_->backup_set_id_, job_attr_->incarnation_id_,
job_attr_->tenant_id_, dest_id, backup_set_file))) { job_attr_->tenant_id_, dest_id, backup_set_file))) {
LOG_WARN("[DATA_BACKUP]failed to get backup set", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to get backup set", K(ret), KPC(job_attr_));
} else if (cluster_version != backup_set_file.tenant_compatible_) { } else if (cluster_version != backup_set_file.tenant_compatible_) {
ret = OB_NOT_SUPPORTED; ret = OB_NOT_SUPPORTED;
LOG_WARN("[DATA_BACKUP]when cluster_version change, backup can't continue", K(ret), K(cluster_version), K(backup_set_file.tenant_compatible_)); LOG_WARN("[DATA_BACKUP]when cluster_version change, backup can't continue", K(ret), K(cluster_version), K(backup_set_file.tenant_compatible_));
@ -1663,7 +1663,7 @@ int ObBackupSetTaskMgr::write_tenant_backup_set_infos_()
int ret = OB_SUCCESS; int ret = OB_SUCCESS;
share::ObTenantBackupSetInfosDesc tenant_backup_set_infos; share::ObTenantBackupSetInfosDesc tenant_backup_set_infos;
if (OB_FAIL(ObBackupSetFileOperator::get_backup_set_files(*sql_proxy_, job_attr_->tenant_id_, tenant_backup_set_infos))) { if (OB_FAIL(ObBackupSetFileOperator::get_backup_set_files(*sql_proxy_, job_attr_->tenant_id_, tenant_backup_set_infos))) {
LOG_WARN("[DATA_BACKUP]failed to get backup set", K(ret), K(*job_attr_)); LOG_WARN("[DATA_BACKUP]failed to get backup set", K(ret), KPC(job_attr_));
} else if (!tenant_backup_set_infos.is_valid()) { } else if (!tenant_backup_set_infos.is_valid()) {
ret = OB_ERR_UNEXPECTED; ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid tenant backup set infos", K(ret), K(tenant_backup_set_infos)); LOG_WARN("invalid tenant backup set infos", K(ret), K(tenant_backup_set_infos));
@ -1685,12 +1685,12 @@ int ObBackupSetTaskMgr::set_backup_set_files_failed_(ObMySQLTransaction &trans)
ObBackupSetFileDesc backup_set_file; ObBackupSetFileDesc backup_set_file;
ObBackupDest backup_dest; ObBackupDest backup_dest;
if (OB_FAIL(ObBackupStorageInfoOperator::get_backup_dest(trans, job_attr_->tenant_id_, set_task_attr_.backup_path_, backup_dest))) { if (OB_FAIL(ObBackupStorageInfoOperator::get_backup_dest(trans, job_attr_->tenant_id_, set_task_attr_.backup_path_, backup_dest))) {
LOG_WARN("fail to get backup dest", K(ret), K(*job_attr_)); LOG_WARN("fail to get backup dest", K(ret), KPC(job_attr_));
} else if (OB_FAIL(ObBackupStorageInfoOperator::get_dest_id(trans, job_attr_->tenant_id_, backup_dest, dest_id))) { } else if (OB_FAIL(ObBackupStorageInfoOperator::get_dest_id(trans, job_attr_->tenant_id_, backup_dest, dest_id))) {
LOG_WARN("failed to get dest id", K(ret), K(*job_attr_)); LOG_WARN("failed to get dest id", K(ret), KPC(job_attr_));
} else if (OB_FAIL(ObBackupSetFileOperator::get_backup_set_file(trans, true/*for update*/, job_attr_->backup_set_id_, job_attr_->incarnation_id_, } else if (OB_FAIL(ObBackupSetFileOperator::get_backup_set_file(trans, true/*for update*/, job_attr_->backup_set_id_, job_attr_->incarnation_id_,
job_attr_->tenant_id_, dest_id, backup_set_file))) { job_attr_->tenant_id_, dest_id, backup_set_file))) {
LOG_WARN("failed to get backup set", K(ret), K(*job_attr_)); LOG_WARN("failed to get backup set", K(ret), KPC(job_attr_));
} else { } else {
backup_set_file.backup_set_id_ = job_attr_->backup_set_id_; backup_set_file.backup_set_id_ = job_attr_->backup_set_id_;
backup_set_file.incarnation_ = job_attr_->incarnation_id_; backup_set_file.incarnation_ = job_attr_->incarnation_id_;