diff --git a/src/observer/omt/ob_multi_tenant.cpp b/src/observer/omt/ob_multi_tenant.cpp index 74df28be5e..be4800b04f 100644 --- a/src/observer/omt/ob_multi_tenant.cpp +++ b/src/observer/omt/ob_multi_tenant.cpp @@ -443,10 +443,10 @@ int ObMultiTenant::init(ObAddr myaddr, MTL_BIND2(mtl_new_default, coordinator::ObFailureDetector::mtl_init, coordinator::ObFailureDetector::mtl_start, coordinator::ObFailureDetector::mtl_stop, coordinator::ObFailureDetector::mtl_wait, mtl_destroy_default); MTL_BIND2(ObLobManager::mtl_new, mtl_init_default, mtl_start_default, mtl_stop_default, mtl_wait_default, mtl_destroy_default); MTL_BIND2(mtl_new_default, ObStorageHAService::mtl_init, mtl_start_default, mtl_stop_default, mtl_wait_default, mtl_destroy_default); - MTL_BIND2(mtl_new_default, rootserver::ObBackupTaskScheduler::mtl_init, nullptr, nullptr, nullptr, mtl_destroy_default); - MTL_BIND2(mtl_new_default, rootserver::ObBackupDataService::mtl_init, nullptr, nullptr, nullptr, mtl_destroy_default); - MTL_BIND2(mtl_new_default, rootserver::ObBackupCleanService::mtl_init, nullptr, nullptr, nullptr, mtl_destroy_default); - MTL_BIND2(mtl_new_default, rootserver::ObArchiveSchedulerService::mtl_init, nullptr, nullptr, nullptr, mtl_destroy_default); + MTL_BIND2(mtl_new_default, rootserver::ObBackupTaskScheduler::mtl_init, nullptr, rootserver::ObBackupTaskScheduler::mtl_stop, rootserver::ObBackupTaskScheduler::mtl_wait, mtl_destroy_default); + MTL_BIND2(mtl_new_default, rootserver::ObBackupDataService::mtl_init, nullptr, rootserver::ObBackupDataService::mtl_stop, rootserver::ObBackupDataService::mtl_wait, mtl_destroy_default); + MTL_BIND2(mtl_new_default, rootserver::ObBackupCleanService::mtl_init, nullptr, rootserver::ObBackupCleanService::mtl_stop, rootserver::ObBackupCleanService::mtl_wait, mtl_destroy_default); + MTL_BIND2(mtl_new_default, rootserver::ObArchiveSchedulerService::mtl_init, nullptr, rootserver::ObArchiveSchedulerService::mtl_stop, rootserver::ObArchiveSchedulerService::mtl_wait, mtl_destroy_default); MTL_BIND2(mtl_new_default, ObGlobalAutoIncService::mtl_init, nullptr, nullptr, nullptr, mtl_destroy_default); MTL_BIND2(mtl_new_default, share::detector::ObDeadLockDetectorMgr::mtl_init, mtl_start_default, mtl_stop_default, mtl_wait_default, mtl_destroy_default); MTL_BIND2(mtl_new_default, ObTenantSchemaService::mtl_init, nullptr, nullptr, nullptr, mtl_destroy_default); diff --git a/src/rootserver/backup/ob_archive_scheduler_service.cpp b/src/rootserver/backup/ob_archive_scheduler_service.cpp index 93932e9a5d..819925816b 100644 --- a/src/rootserver/backup/ob_archive_scheduler_service.cpp +++ b/src/rootserver/backup/ob_archive_scheduler_service.cpp @@ -36,13 +36,16 @@ ObArchiveSchedulerService::ObArchiveSchedulerService() { } -int ObArchiveSchedulerService::mtl_init(ObArchiveSchedulerService *&archive_service) +int ObArchiveSchedulerService::init() { int ret = OB_SUCCESS; common::ObMySQLProxy *sql_proxy = nullptr; obrpc::ObSrvRpcProxy *rpc_proxy = nullptr; share::schema::ObMultiVersionSchemaService *schema_service = nullptr; - if (OB_ISNULL(sql_proxy = GCTX.sql_proxy_)) { + if (IS_INIT) { + ret = OB_INIT_TWICE; + LOG_WARN("archive scheduler init twice", K(ret)); + } else if (OB_ISNULL(sql_proxy = GCTX.sql_proxy_)) { ret = OB_ERR_UNEXPECTED; LOG_WARN("sql_proxy should not be NULL", K(ret), KP(sql_proxy)); } else if (OB_ISNULL(rpc_proxy = GCTX.srv_rpc_proxy_)) { @@ -51,27 +54,12 @@ int ObArchiveSchedulerService::mtl_init(ObArchiveSchedulerService *&archive_serv } else if (OB_ISNULL(schema_service = GCTX.schema_service_)) { ret = OB_ERR_UNEXPECTED; LOG_WARN("schema_service should not be NULL", K(ret), KP(schema_service)); - } else if (OB_FAIL(archive_service->init(*schema_service, *rpc_proxy, *sql_proxy))) { - LOG_WARN("fail to init tenant archive service", K(ret)); - } - return ret; -} - -int ObArchiveSchedulerService::init( - share::schema::ObMultiVersionSchemaService &schema_service, - ObSrvRpcProxy &rpc_proxy, - common::ObMySQLProxy &sql_proxy) -{ - int ret = OB_SUCCESS; - if (IS_INIT) { - ret = OB_INIT_TWICE; - LOG_WARN("archive scheduler init twice", K(ret)); } else if (OB_FAIL(create("ArchiveSvr", *this, ObWaitEventIds::BACKUP_ARCHIVE_SERVICE_COND_WAIT))) { LOG_WARN("failed to create log archive thread", K(ret)); } else { - schema_service_ = &schema_service; - rpc_proxy_ = &rpc_proxy; - sql_proxy_ = &sql_proxy; + schema_service_ = schema_service; + rpc_proxy_ = rpc_proxy; + sql_proxy_ = sql_proxy; tenant_id_ = gen_user_tenant_id(MTL_ID()); is_inited_ = true; } diff --git a/src/rootserver/backup/ob_archive_scheduler_service.h b/src/rootserver/backup/ob_archive_scheduler_service.h index ec7c1d60c9..5cee61cdbd 100644 --- a/src/rootserver/backup/ob_archive_scheduler_service.h +++ b/src/rootserver/backup/ob_archive_scheduler_service.h @@ -43,13 +43,8 @@ public: const int64_t FAST_IDLE_INTERVAL_US = 10 * 1000 * 1000; // 10s, used during BEGINNING or STOPPING //const int64_t MAX_IDLE_INTERVAL_US = 60 * 1000 * 1000; // 60s const int64_t MAX_IDLE_INTERVAL_US = 10 * 1000 * 1000; // 60s - static int mtl_init(ObArchiveSchedulerService *&archive_service); - - int init( - share::schema::ObMultiVersionSchemaService &schema_service, - obrpc::ObSrvRpcProxy &rpc_proxy, - common::ObMySQLProxy &sql_proxy); - + DEFINE_MTL_FUNC(ObArchiveSchedulerService); + int init(); void run2() override; // force cancel archive int force_cancel(const uint64_t tenant_id); diff --git a/src/rootserver/backup/ob_backup_base_service.cpp b/src/rootserver/backup/ob_backup_base_service.cpp index 26a1e363bb..cb85c91d86 100644 --- a/src/rootserver/backup/ob_backup_base_service.cpp +++ b/src/rootserver/backup/ob_backup_base_service.cpp @@ -34,12 +34,12 @@ ObBackupBaseService::~ObBackupBaseService() void ObBackupBaseService::run1() { int tmp_ret = OB_SUCCESS; + lib::set_thread_name(thread_name_); LOG_INFO("ObBackupBaseService thread run", K(thread_name_)); if (OB_UNLIKELY(!is_created_)) { tmp_ret = OB_NOT_INIT; LOG_WARN_RET(OB_NOT_INIT, "not init", K(tmp_ret)); } else { - lib::set_thread_name(thread_name_); ObRSThreadFlag rs_work; run2(); } @@ -222,3 +222,25 @@ int ObBackupBaseService::check_leader() } return ret; } + +void ObBackupBaseService::mtl_thread_stop() +{ + LOG_INFO("[BACKUP_SERVICE] thread stop start", K(tg_id_), K(thread_name_)); + if (-1 != tg_id_) { + TG_STOP(tg_id_); + } + LOG_INFO("[BACKUP_SERVICE] thread stop finish", K(tg_id_), K(thread_name_)); +} + +void ObBackupBaseService::mtl_thread_wait() +{ + LOG_INFO("[BACKUP_SERVICE] thread wait start", K(tg_id_), K(thread_name_)); + if (-1 != tg_id_) { + { + ObThreadCondGuard guard(thread_cond_); + thread_cond_.broadcast(); + } + TG_WAIT(tg_id_); + } + LOG_INFO("[BACKUP_SERVICE] thread wait finish", K(tg_id_), K(thread_name_)); +} \ No newline at end of file diff --git a/src/rootserver/backup/ob_backup_base_service.h b/src/rootserver/backup/ob_backup_base_service.h index c9e4e0ca2a..a894e00cf8 100644 --- a/src/rootserver/backup/ob_backup_base_service.h +++ b/src/rootserver/backup/ob_backup_base_service.h @@ -12,6 +12,7 @@ #define OCEANBASE_ROOTSERVER_OB_BACKUP_BASE_SERVICE_H_ #include "lib/thread/thread_mgr_interface.h" +#include "rootserver/ob_tenant_thread_helper.h" #include "lib/lock/ob_thread_cond.h" #include "logservice/ob_log_base_type.h" #include "storage/ls/ob_ls.h" @@ -44,6 +45,8 @@ public: void wait(); void idle(); void wakeup(); + void mtl_thread_stop(); + void mtl_thread_wait(); void set_idle_time(const int64_t interval_time_us) { interval_idle_time_us_ = interval_time_us; } int64_t get_idle_time() const { return interval_idle_time_us_; } // role change diff --git a/src/rootserver/backup/ob_backup_schedule_task.cpp b/src/rootserver/backup/ob_backup_schedule_task.cpp index 1663cf06a5..b9dc0a5859 100644 --- a/src/rootserver/backup/ob_backup_schedule_task.cpp +++ b/src/rootserver/backup/ob_backup_schedule_task.cpp @@ -423,7 +423,7 @@ int ObBackupDataBaseTask::set_optional_servers_(const ObIArray & for (int i = 0; OB_SUCC(ret) && i < replica_array.count(); ++i) { const ObLSReplica &replica = replica_array.at(i); if (replica.is_in_service() && !replica.is_strong_leader() && replica.is_valid() && !replica.is_in_restore() - && ObReplicaTypeCheck::is_full_replica(replica.get_replica_type()) // TODO(chongrong.th) 5.0 allow R replica backup later + && ObReplicaTypeCheck::is_full_replica(replica.get_replica_type()) // TODO(chongrong.th) 4.3 allow R replica backup later && !check_replica_in_black_server_(replica, black_servers)) { ObBackupServer server; server.set(replica.get_server(), 0/*high priority*/); diff --git a/src/rootserver/backup/ob_backup_service.cpp b/src/rootserver/backup/ob_backup_service.cpp index c2326dfb06..3b281bd40e 100644 --- a/src/rootserver/backup/ob_backup_service.cpp +++ b/src/rootserver/backup/ob_backup_service.cpp @@ -30,26 +30,41 @@ namespace rootserver *----------------------------- ObBackupService ----------------------------- */ -int ObBackupService::init( - common::ObMySQLProxy &sql_proxy, - obrpc::ObSrvRpcProxy &rpc_proxy, - schema::ObMultiVersionSchemaService &schema_service, - share::ObLocationService &loacation_service, - ObBackupTaskScheduler &task_scheduler) +int ObBackupService::init() { int ret = OB_SUCCESS; uint64_t tenant_id = MTL_ID(); + common::ObMySQLProxy *sql_proxy = nullptr; + obrpc::ObSrvRpcProxy *rpc_proxy = nullptr; + share::schema::ObMultiVersionSchemaService *schema_service = nullptr; + ObBackupTaskScheduler *backup_task_scheduler = nullptr; + share::ObLocationService *location_service = nullptr; if (IS_INIT) { ret = OB_INIT_TWICE; LOG_WARN("backup mgr already inited", K(ret)); - } else if (OB_FAIL(task_scheduler.register_backup_srv(*this))) { + } else if (OB_ISNULL(sql_proxy = GCTX.sql_proxy_)) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("sql_proxy should not be NULL", K(ret), KP(sql_proxy)); + } else if (OB_ISNULL(rpc_proxy = GCTX.srv_rpc_proxy_)) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("rpc_proxy should not be NULL", K(ret), KP(rpc_proxy)); + } else if (OB_ISNULL(schema_service = GCTX.schema_service_)) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("schema_service should not be NULL", K(ret), KP(schema_service)); + } else if (OB_ISNULL(backup_task_scheduler = MTL(ObBackupTaskScheduler *))) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("backup_task_scheduler should not be NULL", K(ret), KP(backup_task_scheduler)); + } else if (OB_ISNULL(location_service = GCTX.location_service_)) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("location_service should not be NULL", K(ret), KP(backup_task_scheduler)); + } else if (OB_FAIL(backup_task_scheduler->register_backup_srv(*this))) { LOG_WARN("failed to register backup srv", K(ret)); - } else if (OB_FAIL(sub_init(sql_proxy, rpc_proxy, schema_service, loacation_service, task_scheduler))) { + } else if (OB_FAIL(sub_init(*sql_proxy, *rpc_proxy, *schema_service, *location_service, *backup_task_scheduler))) { LOG_WARN("failed to do sub init", K(ret)); } else { tenant_id_ = tenant_id; - task_scheduler_ = &task_scheduler; - schema_service_ = &schema_service; + task_scheduler_ = backup_task_scheduler; + schema_service_ = schema_service; is_inited_ = true; } return ret; @@ -69,7 +84,7 @@ void ObBackupService::run2() LOG_WARN("fail to get schema guard", KR(ret)); } else if (OB_FAIL(schema_guard.get_tenant_info(tenant_id_, tenant_schema))) { LOG_WARN("failed to get schema ", KR(ret), K(tenant_id_)); - } else if (tenant_schema->is_normal()) { + } else if (OB_NOT_NULL(tenant_schema) && tenant_schema->is_normal()) { if (can_schedule()) { process(last_trigger_ts); } else { @@ -115,35 +130,6 @@ void ObBackupService::destroy() *----------------------------- ObBackupDataService ----------------------------- */ -int ObBackupDataService::mtl_init(ObBackupDataService *&srv) -{ - int ret = OB_SUCCESS; - common::ObMySQLProxy *sql_proxy = nullptr; - obrpc::ObSrvRpcProxy *rpc_proxy = nullptr; - share::schema::ObMultiVersionSchemaService *schema_service = nullptr; - ObBackupTaskScheduler *backup_task_scheduler = nullptr; - share::ObLocationService *location_service = nullptr; - if (OB_ISNULL(sql_proxy = GCTX.sql_proxy_)) { - ret = OB_ERR_UNEXPECTED; - LOG_WARN("sql_proxy should not be NULL", K(ret), KP(sql_proxy)); - } else if (OB_ISNULL(rpc_proxy = GCTX.srv_rpc_proxy_)) { - ret = OB_ERR_UNEXPECTED; - LOG_WARN("rpc_proxy should not be NULL", K(ret), KP(rpc_proxy)); - } else if (OB_ISNULL(schema_service = GCTX.schema_service_)) { - ret = OB_ERR_UNEXPECTED; - LOG_WARN("schema_service should not be NULL", K(ret), KP(schema_service)); - } else if (OB_ISNULL(backup_task_scheduler = MTL(ObBackupTaskScheduler *))) { - ret = OB_ERR_UNEXPECTED; - LOG_WARN("backup_task_scheduler should not be NULL", K(ret), KP(backup_task_scheduler)); - } else if (OB_ISNULL(location_service = GCTX.location_service_)) { - ret = OB_ERR_UNEXPECTED; - LOG_WARN("location_service should not be NULL", K(ret), KP(backup_task_scheduler)); - } else if (OB_FAIL(srv->init(*sql_proxy, *rpc_proxy, *schema_service, *location_service, *backup_task_scheduler))) { - LOG_WARN("fail to ini backup service"); - } - return ret; -} - int ObBackupDataService::sub_init( common::ObMySQLProxy &sql_proxy, obrpc::ObSrvRpcProxy &rpc_proxy, @@ -238,36 +224,6 @@ int ObBackupDataService::handle_backup_database_cancel(const uint64_t tenant_id, *----------------------------- ObBackupCleanService ----------------------------- */ - -int ObBackupCleanService::mtl_init(ObBackupCleanService *&srv) -{ - int ret = OB_SUCCESS; - common::ObMySQLProxy *sql_proxy = nullptr; - obrpc::ObSrvRpcProxy *rpc_proxy = nullptr; - share::schema::ObMultiVersionSchemaService *schema_service = nullptr; - ObBackupTaskScheduler *backup_task_scheduler = nullptr; - share::ObLocationService *location_service = nullptr; - if (OB_ISNULL(sql_proxy = GCTX.sql_proxy_)) { - ret = OB_ERR_UNEXPECTED; - LOG_WARN("sql_proxy should not be NULL", K(ret), KP(sql_proxy)); - } else if (OB_ISNULL(rpc_proxy = GCTX.srv_rpc_proxy_)) { - ret = OB_ERR_UNEXPECTED; - LOG_WARN("rpc_proxy should not be NULL", K(ret), KP(rpc_proxy)); - } else if (OB_ISNULL(schema_service = GCTX.schema_service_)) { - ret = OB_ERR_UNEXPECTED; - LOG_WARN("schema_service should not be NULL", K(ret), KP(schema_service)); - } else if (OB_ISNULL(backup_task_scheduler = MTL(ObBackupTaskScheduler *))) { - ret = OB_ERR_UNEXPECTED; - LOG_WARN("backup_task_scheduler should not be NULL", K(ret), KP(backup_task_scheduler)); - } else if (OB_ISNULL(location_service = GCTX.location_service_)) { - ret = OB_ERR_UNEXPECTED; - LOG_WARN("location_service should not be NULL", K(ret), KP(backup_task_scheduler)); - } else if (OB_FAIL(srv->init(*sql_proxy, *rpc_proxy, *schema_service, *location_service, *backup_task_scheduler))) { - LOG_WARN("fail to ini backup service"); - } - return ret; -} - int ObBackupCleanService::sub_init( common::ObMySQLProxy &sql_proxy, obrpc::ObSrvRpcProxy &rpc_proxy, diff --git a/src/rootserver/backup/ob_backup_service.h b/src/rootserver/backup/ob_backup_service.h index d40f7b508c..8bb958a54c 100644 --- a/src/rootserver/backup/ob_backup_service.h +++ b/src/rootserver/backup/ob_backup_service.h @@ -28,10 +28,7 @@ public: ObBackupService(): is_inited_(false), tenant_id_(OB_INVALID_TENANT_ID), can_schedule_(false), task_scheduler_(nullptr), schema_service_(nullptr) {} virtual ~ObBackupService() {}; - int init(common::ObMySQLProxy &sql_proxy, obrpc::ObSrvRpcProxy &rpc_proxy, - share::schema::ObMultiVersionSchemaService &schema_service, - share::ObLocationService &loacation_service, - ObBackupTaskScheduler &task_scheduler); + int init(); void run2() override final; virtual int process(int64_t &last_schedule_ts) = 0; void destroy() override final; @@ -71,7 +68,7 @@ class ObBackupDataService final : public ObBackupService public: ObBackupDataService(): ObBackupService(), backup_data_scheduler_() {} virtual ~ObBackupDataService() {} - static int mtl_init(ObBackupDataService *&srv); + DEFINE_MTL_FUNC(ObBackupDataService); int process(int64_t &last_schedule_ts) override; ObIBackupJobScheduler *get_scheduler(const BackupJobType &type); @@ -95,7 +92,7 @@ public: ObBackupCleanService() : ObBackupService(), backup_clean_scheduler_(), backup_auto_obsolete_delete_trigger_(), jobs_(), triggers_() {} virtual ~ObBackupCleanService() {} - static int mtl_init(ObBackupCleanService *&srv); + DEFINE_MTL_FUNC(ObBackupCleanService); int process(int64_t &last_schedule_ts) override; ObIBackupJobScheduler *get_scheduler(const BackupJobType &type); diff --git a/src/rootserver/backup/ob_backup_task_scheduler.cpp b/src/rootserver/backup/ob_backup_task_scheduler.cpp index d23d3f94ab..680be7d8f3 100644 --- a/src/rootserver/backup/ob_backup_task_scheduler.cpp +++ b/src/rootserver/backup/ob_backup_task_scheduler.cpp @@ -1124,13 +1124,16 @@ ObBackupTaskScheduler::ObBackupTaskScheduler() { } -int ObBackupTaskScheduler::mtl_init(ObBackupTaskScheduler *&backup_task_scheduler) +int ObBackupTaskScheduler::init() { int ret = OB_SUCCESS; common::ObMySQLProxy *sql_proxy = GCTX.sql_proxy_; obrpc::ObSrvRpcProxy *rpc_proxy = GCTX.srv_rpc_proxy_; share::schema::ObMultiVersionSchemaService *schema_service = GCTX.schema_service_; - if (OB_ISNULL(sql_proxy)) { + if (IS_INIT) { + ret = OB_INIT_TWICE; + LOG_WARN("init twice", K(ret)); + } else if (OB_ISNULL(sql_proxy)) { ret = OB_ERR_UNEXPECTED; LOG_WARN("sql_proxy should not be NULL", K(ret), KP(sql_proxy)); } else if (OB_ISNULL(rpc_proxy)) { @@ -1139,21 +1142,6 @@ int ObBackupTaskScheduler::mtl_init(ObBackupTaskScheduler *&backup_task_schedule } else if (OB_ISNULL(schema_service)) { ret = OB_ERR_UNEXPECTED; LOG_WARN("scheam service can not be NULL", K(ret), KP(schema_service)); - } else if (OB_FAIL(backup_task_scheduler->init(rpc_proxy, *sql_proxy, *schema_service))) { - LOG_WARN("fail to init backup_task_scheduler", K(ret)); - } - return ret; -} - -int ObBackupTaskScheduler::init( - obrpc::ObSrvRpcProxy *rpc_proxy, - common::ObMySQLProxy &sql_proxy, - share::schema::ObMultiVersionSchemaService &schema_service) -{ - int ret = OB_SUCCESS; - if (IS_INIT) { - ret = OB_INIT_TWICE; - LOG_WARN("init twice", K(ret)); } else if (OB_UNLIKELY(nullptr == rpc_proxy)) { ret = OB_INVALID_ARGUMENT; LOG_WARN("invalid argument", K(ret), K(rpc_proxy)); @@ -1162,11 +1150,11 @@ int ObBackupTaskScheduler::init( } else { tenant_id_ = MTL_ID(); rpc_proxy_ = rpc_proxy; - schema_service_ = &schema_service; - if (OB_FAIL(queue_.init(MAX_BACKUP_TASK_QUEUE_LIMIT, rpc_proxy_, this, MAX_BACKUP_TASK_QUEUE_LIMIT, sql_proxy))) { + schema_service_ = schema_service; + if (OB_FAIL(queue_.init(MAX_BACKUP_TASK_QUEUE_LIMIT, rpc_proxy_, this, MAX_BACKUP_TASK_QUEUE_LIMIT, *sql_proxy))) { LOG_WARN("init rebalance task queue failed", K(ret), LITERAL_K(MAX_BACKUP_TASK_QUEUE_LIMIT)); } else { - sql_proxy_ = &sql_proxy; + sql_proxy_ = sql_proxy; is_inited_ = true; } } diff --git a/src/rootserver/backup/ob_backup_task_scheduler.h b/src/rootserver/backup/ob_backup_task_scheduler.h index 751cb11956..3f2c105f72 100644 --- a/src/rootserver/backup/ob_backup_task_scheduler.h +++ b/src/rootserver/backup/ob_backup_task_scheduler.h @@ -142,10 +142,8 @@ public: public: ObBackupTaskScheduler(); virtual ~ObBackupTaskScheduler() {} - static int mtl_init(ObBackupTaskScheduler *&backup_task_scheduler); - int init(obrpc::ObSrvRpcProxy *rpc_proxy, - common::ObMySQLProxy &sql_proxy, - share::schema::ObMultiVersionSchemaService &schema_service); + DEFINE_MTL_FUNC(ObBackupTaskScheduler); + int init(); virtual void run2() override final; virtual void destroy() override final; diff --git a/src/share/backup/ob_backup_struct.h b/src/share/backup/ob_backup_struct.h index 8afba7eb11..055d274b99 100755 --- a/src/share/backup/ob_backup_struct.h +++ b/src/share/backup/ob_backup_struct.h @@ -34,7 +34,7 @@ namespace oceanbase namespace storage { -class ObBackupLSMetaInfosDesc; //TODO(chongrong): fix namespace circular dependency +class ObBackupLSMetaInfosDesc; } namespace share { diff --git a/src/storage/backup/ob_backup_extern_info_mgr.h b/src/storage/backup/ob_backup_extern_info_mgr.h index f1d098491e..76b9b1da33 100644 --- a/src/storage/backup/ob_backup_extern_info_mgr.h +++ b/src/storage/backup/ob_backup_extern_info_mgr.h @@ -24,7 +24,6 @@ #ifndef STORAGE_LOG_STREAM_BACKUP_EXTERN_INFO_MGR_H_ #define STORAGE_LOG_STREAM_BACKUP_EXTERN_INFO_MGR_H_ -// TODO(chongrong.th) merge this file to ob_backup_data_store.h later. namespace oceanbase { namespace backup { diff --git a/src/storage/backup/ob_backup_utils.cpp b/src/storage/backup/ob_backup_utils.cpp index b9ee3e4031..43290aefc9 100755 --- a/src/storage/backup/ob_backup_utils.cpp +++ b/src/storage/backup/ob_backup_utils.cpp @@ -1776,7 +1776,7 @@ int ObBackupTabletProvider::check_tx_data_can_explain_user_data_( // If tablet has no minor sstable, or has no uncommitted row in sstable, it's also no need to check tx_data. // The condition that tx_data can explain user data is that tx_data_table's filled_tx_scn is less than the // minimum tablet's minor sstable's filled_tx_scn. - // TODO(chongrong.th): But when transfer supports not killing transaction, minor sstable may have uncommitted rows and it's + // TODO(chongrong.th): 4.3 But when transfer supports not killing transaction, minor sstable may have uncommitted rows and it's // filled_tx_scn may less than tx_data_table's filled_tx_scn, which is a bad case. Fix this in future by handora.qc. if (OB_ISNULL(tablet = tablet_handle.get_obj())) { diff --git a/src/storage/high_availability/ob_storage_ha_tablet_builder.cpp b/src/storage/high_availability/ob_storage_ha_tablet_builder.cpp index eccd5ae5a7..73bba6135c 100755 --- a/src/storage/high_availability/ob_storage_ha_tablet_builder.cpp +++ b/src/storage/high_availability/ob_storage_ha_tablet_builder.cpp @@ -298,7 +298,13 @@ int ObStorageHATabletsBuilder::update_pending_tablets_with_remote() const ObTabletID tablet_id = tablet_info.tablet_id_; if (OB_FAIL(ls->ha_get_tablet(tablet_id, tablet_handle))) { - LOG_WARN("failed to get tablet", K(ret), K(tablet_id)); + if (OB_TABLET_NOT_EXIST) { + LOG_INFO("tablet is not exist", K(tablet_id)); + ret = OB_SUCCESS; + continue; + } else { + LOG_WARN("failed to get tablet", K(ret), K(tablet_id)); + } } else if (OB_ISNULL(tablet = tablet_handle.get_obj())) { ret = OB_ERR_UNEXPECTED; LOG_WARN("tablet should not be NULL", K(ret), K(tablet_id)); diff --git a/src/storage/high_availability/ob_tablet_group_restore.cpp b/src/storage/high_availability/ob_tablet_group_restore.cpp index 85e3da8c37..11c2bc1852 100644 --- a/src/storage/high_availability/ob_tablet_group_restore.cpp +++ b/src/storage/high_availability/ob_tablet_group_restore.cpp @@ -824,6 +824,8 @@ int ObInitialTabletGroupRestoreTask::check_local_tablets_restore_status_() ret = OB_ERR_UNEXPECTED; LOG_WARN("tablet restore status is invalid", K(ret), K(tablet_id), K(action_restore_status), K(tablet_restore_status), K(ctx_->arg_)); + } else if (ObTabletRestoreStatus::is_undefined(tablet_restore_status)) { + LOG_INFO("tablet restore status is undefined, skip restore it", K(ret)); } else if (OB_FAIL(ObTabletRestoreStatus::check_can_change_status(tablet_restore_status, action_restore_status, can_change))) { LOG_WARN("failed to check can change status", K(ret), K(tablet_restore_status),