diff --git a/mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h b/mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h index 9b0e82539..2af73e3e7 100644 --- a/mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h +++ b/mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h @@ -238,7 +238,7 @@ void TestIndexBlockDataPrepare::SetUpTestCase() void TestIndexBlockDataPrepare::TearDownTestCase() { - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ObLSID(ls_id_), false)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ObLSID(ls_id_))); ObKVGlobalCache::get_instance().destroy(); OB_STORE_CACHE.destroy(); MockTenantModuleEnv::get_instance().destroy(); diff --git a/mittest/mtlenv/storage/checkpoint/test_checkpoint_executor.cpp b/mittest/mtlenv/storage/checkpoint/test_checkpoint_executor.cpp index 66add3e5d..977861498 100644 --- a/mittest/mtlenv/storage/checkpoint/test_checkpoint_executor.cpp +++ b/mittest/mtlenv/storage/checkpoint/test_checkpoint_executor.cpp @@ -300,7 +300,7 @@ TEST_F(TestCheckpointExecutor, calculate_checkpoint) ASSERT_EQ(true, tmp == memtable1.get_rec_scn()); handle.reset(); - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id, false)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id)); } TEST_F(TestCheckpointExecutor, timer_verify_rec_scn_stable) @@ -329,7 +329,7 @@ TEST_F(TestCheckpointExecutor, timer_verify_rec_scn_stable) ASSERT_EQ(3, data_checkpoint->active_list_.checkpoint_list_.get_size()); handle.reset(); - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id, false)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id)); } } diff --git a/mittest/mtlenv/storage/checkpoint/test_data_checkpoint.cpp b/mittest/mtlenv/storage/checkpoint/test_data_checkpoint.cpp index 816be165d..15e84e917 100644 --- a/mittest/mtlenv/storage/checkpoint/test_data_checkpoint.cpp +++ b/mittest/mtlenv/storage/checkpoint/test_data_checkpoint.cpp @@ -218,7 +218,7 @@ TEST_F(TestDataCheckpoint, dlink_base) // for exist handle.reset(); //ASSERT_EQ(OB_SUCCESS, ls->disable_palf(true)); - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id, false)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id)); } TEST_F(TestDataCheckpoint, ls_freeze) @@ -279,7 +279,7 @@ TEST_F(TestDataCheckpoint, ls_freeze) // for exist handle.reset(); //ASSERT_EQ(OB_SUCCESS, ls->disable_palf(true)); - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id, false)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id)); } } diff --git a/mittest/mtlenv/storage/checkpoint/test_lock_memtable_checkpoint.cpp b/mittest/mtlenv/storage/checkpoint/test_lock_memtable_checkpoint.cpp index a6d170e61..ec5fa7dc6 100644 --- a/mittest/mtlenv/storage/checkpoint/test_lock_memtable_checkpoint.cpp +++ b/mittest/mtlenv/storage/checkpoint/test_lock_memtable_checkpoint.cpp @@ -205,7 +205,7 @@ TEST_F(TestLockMemtableCheckpoint, replay_disorder) LOG_INFO("TestLockMemtableCheckpoint::replay_disorder 11"); table_handle_.reset(); ls_handle_.reset(); - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id_, false)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id_)); } } // namespace tablelock } // namespace transaction diff --git a/mittest/mtlenv/storage/test_lob_manager.cpp b/mittest/mtlenv/storage/test_lob_manager.cpp index fac57cc7a..1e33c2f28 100644 --- a/mittest/mtlenv/storage/test_lob_manager.cpp +++ b/mittest/mtlenv/storage/test_lob_manager.cpp @@ -932,7 +932,7 @@ TEST_F(TestLobManager, basic) // for exist // the iter has store ctx and store ctx has one ls handle. // iter->reset(); - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id_, false)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id_)); } // TEST_F(TestLobManager, basic2) diff --git a/mittest/mtlenv/storage/test_ls_migration_param.cpp b/mittest/mtlenv/storage/test_ls_migration_param.cpp index b9778f2b3..be02dd492 100644 --- a/mittest/mtlenv/storage/test_ls_migration_param.cpp +++ b/mittest/mtlenv/storage/test_ls_migration_param.cpp @@ -80,7 +80,7 @@ void TestLSMigrationParam::SetUpTestCase() void TestLSMigrationParam::TearDownTestCase() { int ret = OB_SUCCESS; - ret = MTL(ObLSService*)->remove_ls(ObLSID(TEST_LS_ID), false); + ret = MTL(ObLSService*)->remove_ls(ObLSID(TEST_LS_ID)); ASSERT_EQ(OB_SUCCESS, ret); MockTenantModuleEnv::get_instance().destroy(); diff --git a/mittest/mtlenv/storage/test_ls_restore_task_mgr.cpp b/mittest/mtlenv/storage/test_ls_restore_task_mgr.cpp index 95cd9c89f..e8e27a67f 100644 --- a/mittest/mtlenv/storage/test_ls_restore_task_mgr.cpp +++ b/mittest/mtlenv/storage/test_ls_restore_task_mgr.cpp @@ -664,7 +664,7 @@ TEST_F(TestLSRestoreHandler, wait_state) EXPECT_EQ(ObLSRestoreStatus::Status::WAIT_RESTORE_MAJOR_DATA, ls->ls_meta_.restore_status_); ObLSService *ls_svr = MTL(ObLSService*); - EXPECT_EQ(OB_SUCCESS, ls_svr->remove_ls(ObLSID(100), true)); + EXPECT_EQ(OB_SUCCESS, ls_svr->remove_ls(ObLSID(100))); LOG_INFO("TestLSRestoreHandler::wait_state finish"); } diff --git a/mittest/mtlenv/storage/test_ls_service.cpp b/mittest/mtlenv/storage/test_ls_service.cpp index e3d1b6a81..87da08d2e 100644 --- a/mittest/mtlenv/storage/test_ls_service.cpp +++ b/mittest/mtlenv/storage/test_ls_service.cpp @@ -144,16 +144,16 @@ TEST_F(TestLSService, basic) // 1. remove not exist. EXPECT_EQ(OB_SUCCESS, ls_svr->check_ls_exist(not_exist_id, exist)); EXPECT_FALSE(exist); - EXPECT_EQ(OB_SUCCESS, ls_svr->remove_ls(not_exist_id, true)); + EXPECT_EQ(OB_SUCCESS, ls_svr->remove_ls(not_exist_id)); // 2. remove exist. EXPECT_EQ(OB_SUCCESS, ls_svr->check_ls_exist(id_100, exist)); EXPECT_TRUE(exist); - EXPECT_EQ(OB_SUCCESS, ls_svr->remove_ls(id_100, true)); + EXPECT_EQ(OB_SUCCESS, ls_svr->remove_ls(id_100)); EXPECT_EQ(OB_SUCCESS, ls_svr->check_ls_exist(id_100, exist)); EXPECT_FALSE(exist); - EXPECT_EQ(OB_SUCCESS, ls_svr->remove_ls(id_102, true)); + EXPECT_EQ(OB_SUCCESS, ls_svr->remove_ls(id_102)); // 3. check empty iter. iter.reset(); @@ -221,7 +221,7 @@ TEST_F(TestLSService, tablet_test) remove_tablet_arg.tablet_ids_.push_back(tablet_id); ASSERT_EQ(OB_SUCCESS, TestTabletHelper::remove_tablet(handle, tablet_id)); - EXPECT_EQ(OB_SUCCESS, ls_svr->remove_ls(ls_id, true)); + EXPECT_EQ(OB_SUCCESS, ls_svr->remove_ls(ls_id)); } TEST_F(TestLSService, ls_safe_destroy) @@ -256,7 +256,7 @@ TEST_F(TestLSService, ls_safe_destroy) // 3. remove ls LOG_INFO("TestLSService::ls_safe_destroy 1.3"); - ASSERT_EQ(OB_SUCCESS, ls_svr->remove_ls(id_104, true)); + ASSERT_EQ(OB_SUCCESS, ls_svr->remove_ls(id_104)); ASSERT_EQ(OB_SUCCESS, ls_svr->check_ls_exist(id_104, exist)); ASSERT_FALSE(exist); @@ -287,11 +287,68 @@ TEST_F(TestLSService, ls_safe_destroy) // 7. remove ls LOG_INFO("TestLSService::ls_safe_destroy 1.7"); - ASSERT_EQ(OB_SUCCESS, ls_svr->remove_ls(id_104, true)); + ASSERT_EQ(OB_SUCCESS, ls_svr->remove_ls(id_104)); ASSERT_EQ(OB_SUCCESS, ls_svr->check_ls_exist(id_104, exist)); ASSERT_FALSE(exist); } +TEST_F(TestLSService, create_and_clean) +{ + int ret = OB_SUCCESS; + uint64_t tenant_id = MTL_ID(); + ObCreateLSArg arg; + ObLSService* ls_svr = MTL(ObLSService*); + bool exist = false; + bool waiting = false; + ObLSID id_105(105); + int64_t MAX_CREATE_STEP = 100; + int cnt = 0; + + LOG_INFO("TestLSService::create_and_clean"); + ASSERT_EQ(OB_SUCCESS, gen_create_ls_arg(tenant_id, id_105, arg)); + for (int64_t i = 1; i < MAX_CREATE_STEP; i++) { + LOG_INFO("create ls break point", K(i)); + ls_svr->break_point = i; + if (OB_FAIL(ls_svr->create_ls(arg)) && OB_BREAK_BY_TEST == ret) { + // check exist + ASSERT_EQ(OB_SUCCESS, ls_svr->check_ls_exist(id_105, exist)); + ASSERT_FALSE(exist); + // wait safe destroy + cnt = 0; + while (cnt++ < 20) { + ASSERT_EQ(OB_SUCCESS, ls_svr->check_ls_waiting_safe_destroy(id_105, waiting)); + if (waiting) { + ::sleep(1); + } else { + break; + } + } + ASSERT_FALSE(waiting); + } else if (OB_FAIL(ret)) { + LOG_WARN("create failed but not break by test", K(ret), K(id_105)); + } else { + // create success and finish the break test + ASSERT_EQ(OB_SUCCESS, ls_svr->check_ls_exist(id_105, exist)); + ASSERT_TRUE(exist); + ASSERT_EQ(OB_SUCCESS, ls_svr->remove_ls(id_105)); + ASSERT_EQ(OB_SUCCESS, ls_svr->check_ls_exist(id_105, exist)); + ASSERT_FALSE(exist); + break; + } + } + cnt = 0; + while (cnt++ < 20) { + ASSERT_EQ(OB_SUCCESS, ls_svr->check_ls_waiting_safe_destroy(id_105, waiting)); + if (waiting) { + ::sleep(1); + } else { + break; + } + } + ASSERT_FALSE(waiting); +} + + } // namespace storage } // namespace oceanbase diff --git a/mittest/mtlenv/storage/test_ls_tablet_info_writer_and_reader.cpp b/mittest/mtlenv/storage/test_ls_tablet_info_writer_and_reader.cpp index c6075c29e..7c348b50a 100644 --- a/mittest/mtlenv/storage/test_ls_tablet_info_writer_and_reader.cpp +++ b/mittest/mtlenv/storage/test_ls_tablet_info_writer_and_reader.cpp @@ -104,7 +104,7 @@ void TestLSTabletInfoWR::SetUpTestCase() void TestLSTabletInfoWR::TearDownTestCase() { int ret = OB_SUCCESS; - ret = MTL(ObLSService*)->remove_ls(ObLSID(TEST_LS_ID), false); + ret = MTL(ObLSService*)->remove_ls(ObLSID(TEST_LS_ID)); ASSERT_EQ(OB_SUCCESS, ret); MockTenantModuleEnv::get_instance().destroy(); diff --git a/mittest/mtlenv/storage/test_ls_tablet_service.cpp b/mittest/mtlenv/storage/test_ls_tablet_service.cpp index 42750630c..e0263c06f 100644 --- a/mittest/mtlenv/storage/test_ls_tablet_service.cpp +++ b/mittest/mtlenv/storage/test_ls_tablet_service.cpp @@ -132,7 +132,7 @@ void TestLSTabletService::SetUp() void TestLSTabletService::TearDownTestCase() { int ret = OB_SUCCESS; - ret = MTL(ObLSService*)->remove_ls(ObLSID(TEST_LS_ID), false); + ret = MTL(ObLSService*)->remove_ls(ObLSID(TEST_LS_ID)); ASSERT_EQ(OB_SUCCESS, ret); MockTenantModuleEnv::get_instance().destroy(); diff --git a/mittest/mtlenv/storage/test_medium_info_reader.cpp b/mittest/mtlenv/storage/test_medium_info_reader.cpp index b0afa2ea8..1e53f9fb6 100644 --- a/mittest/mtlenv/storage/test_medium_info_reader.cpp +++ b/mittest/mtlenv/storage/test_medium_info_reader.cpp @@ -151,7 +151,7 @@ int TestMediumInfoReader::create_ls(const uint64_t tenant_id, const share::ObLSI int TestMediumInfoReader::remove_ls(const share::ObLSID &ls_id) { int ret = OB_SUCCESS; - ret = MTL(ObLSService*)->remove_ls(ls_id, false); + ret = MTL(ObLSService*)->remove_ls(ls_id); return ret; } diff --git a/mittest/mtlenv/storage/test_memtable_v2.cpp b/mittest/mtlenv/storage/test_memtable_v2.cpp index 173a52b73..5d1cb9f1d 100644 --- a/mittest/mtlenv/storage/test_memtable_v2.cpp +++ b/mittest/mtlenv/storage/test_memtable_v2.cpp @@ -214,7 +214,7 @@ public: { // remove ls ObLSID ls_id(1001); - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id, false)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id)); MockTenantModuleEnv::get_instance().destroy(); TRANS_LOG(INFO, "TearDownTestCase"); diff --git a/mittest/mtlenv/storage/test_table_scan_pure_data_table.cpp b/mittest/mtlenv/storage/test_table_scan_pure_data_table.cpp index 08f669600..98b7a4027 100644 --- a/mittest/mtlenv/storage/test_table_scan_pure_data_table.cpp +++ b/mittest/mtlenv/storage/test_table_scan_pure_data_table.cpp @@ -263,7 +263,7 @@ TEST_F(TestTableScanPureDataTable, table_scan_pure_data_table) // for exist // the iter has store ctx and store ctx has one ls handle. iter->reset(); - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id_, false)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id_)); } } // namespace storage } // namespace oceanbase diff --git a/mittest/mtlenv/storage/test_tablet_create_delete_helper.cpp b/mittest/mtlenv/storage/test_tablet_create_delete_helper.cpp index 7932f61e7..b62e47e11 100644 --- a/mittest/mtlenv/storage/test_tablet_create_delete_helper.cpp +++ b/mittest/mtlenv/storage/test_tablet_create_delete_helper.cpp @@ -133,7 +133,7 @@ void TestTabletCreateDeleteHelper::TearDownTestCase() ret = t3m->init(); ASSERT_EQ(OB_SUCCESS, ret); - ret = MTL(ObLSService*)->remove_ls(ObLSID(TEST_LS_ID), false); + ret = MTL(ObLSService*)->remove_ls(ObLSID(TEST_LS_ID)); ASSERT_EQ(OB_SUCCESS, ret); MockTenantModuleEnv::get_instance().destroy(); diff --git a/mittest/mtlenv/storage/test_tablet_member_load_and_free.cpp b/mittest/mtlenv/storage/test_tablet_member_load_and_free.cpp index 45109c40a..181f111ae 100644 --- a/mittest/mtlenv/storage/test_tablet_member_load_and_free.cpp +++ b/mittest/mtlenv/storage/test_tablet_member_load_and_free.cpp @@ -109,7 +109,7 @@ int TestTabletMemberLoadAndFree::create_ls(const uint64_t tenant_id, const share int TestTabletMemberLoadAndFree::remove_ls(const share::ObLSID &ls_id) { int ret = OB_SUCCESS; - ret = MTL(ObLSService*)->remove_ls(ls_id, false); + ret = MTL(ObLSService*)->remove_ls(ls_id); return ret; } diff --git a/mittest/mtlenv/storage/test_tablet_status.cpp b/mittest/mtlenv/storage/test_tablet_status.cpp index ca5fdeacd..b078e729c 100644 --- a/mittest/mtlenv/storage/test_tablet_status.cpp +++ b/mittest/mtlenv/storage/test_tablet_status.cpp @@ -118,7 +118,7 @@ void TestTabletStatus::TearDownTestCase() ret = t3m->init(); ASSERT_EQ(OB_SUCCESS, ret); - ret = MTL(ObLSService*)->remove_ls(ObLSID(TEST_LS_ID), false); + ret = MTL(ObLSService*)->remove_ls(ObLSID(TEST_LS_ID)); ASSERT_EQ(OB_SUCCESS, ret); MockTenantModuleEnv::get_instance().destroy(); diff --git a/mittest/mtlenv/storage/test_tablet_status_cache.cpp b/mittest/mtlenv/storage/test_tablet_status_cache.cpp index 60f37c9f1..4c2be2476 100644 --- a/mittest/mtlenv/storage/test_tablet_status_cache.cpp +++ b/mittest/mtlenv/storage/test_tablet_status_cache.cpp @@ -110,7 +110,7 @@ int TestTabletStatusCache::create_ls(const uint64_t tenant_id, const share::ObLS int TestTabletStatusCache::remove_ls(const share::ObLSID &ls_id) { int ret = OB_SUCCESS; - ret = MTL(ObLSService*)->remove_ls(ls_id, false); + ret = MTL(ObLSService*)->remove_ls(ls_id); return ret; } diff --git a/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp b/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp index 9f214b88b..311e82166 100644 --- a/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp +++ b/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp @@ -155,7 +155,7 @@ void TestTenantMetaMemMgr::SetUp() void TestTenantMetaMemMgr::TearDownTestCase() { int ret = OB_SUCCESS; - ret = MTL(ObLSService*)->remove_ls(ObLSID(TEST_LS_ID), false); + ret = MTL(ObLSService*)->remove_ls(ObLSID(TEST_LS_ID)); ASSERT_EQ(OB_SUCCESS, ret); MockTenantModuleEnv::get_instance().destroy(); } diff --git a/mittest/mtlenv/storage/test_trans.cpp b/mittest/mtlenv/storage/test_trans.cpp index 10c79fd07..cc2bf84f1 100644 --- a/mittest/mtlenv/storage/test_trans.cpp +++ b/mittest/mtlenv/storage/test_trans.cpp @@ -307,7 +307,7 @@ TEST_F(TestTrans, basic) LOG_INFO("release transaction"); tx_service->release_tx(*tx_desc); - //ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id, false)); + //ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id)); } TEST_F(TestTrans, dist_trans) @@ -444,8 +444,8 @@ TEST_F(TestTrans, remove_ls) { ObLSID ls_id(100); ObLSID ls_id2(101); - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id, false)); - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id2, false)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id2)); } diff --git a/mittest/mtlenv/storage/test_write_tablet_slog.cpp b/mittest/mtlenv/storage/test_write_tablet_slog.cpp index a7af413dc..cf7e63a25 100644 --- a/mittest/mtlenv/storage/test_write_tablet_slog.cpp +++ b/mittest/mtlenv/storage/test_write_tablet_slog.cpp @@ -80,7 +80,7 @@ void TestWriteTabletSlog::SetUpTestCase() void TestWriteTabletSlog::TearDownTestCase() { int ret = OB_SUCCESS; - ret = MTL(ObLSService*)->remove_ls(ObLSID(TEST_LS_ID), false); + ret = MTL(ObLSService*)->remove_ls(ObLSID(TEST_LS_ID)); ASSERT_EQ(OB_SUCCESS, ret); startup_accel_handler_.destroy(); diff --git a/mittest/mtlenv/tablelock/test_table_lock_flush.cpp b/mittest/mtlenv/tablelock/test_table_lock_flush.cpp index 8bfb8b1db..ec7a54a30 100644 --- a/mittest/mtlenv/tablelock/test_table_lock_flush.cpp +++ b/mittest/mtlenv/tablelock/test_table_lock_flush.cpp @@ -217,7 +217,7 @@ TEST_F(TestTableLockFlush, checkpoint) LOCK_OP_COMPLETE)); ASSERT_EQ(table_lock_op2_commit_scn, memtable->get_rec_scn()); - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id, true)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id)); } TEST_F(TestTableLockFlush, restore_tablelock_memtable) @@ -339,7 +339,7 @@ TEST_F(TestTableLockFlush, restore_tablelock_memtable) ASSERT_EQ(share::SCN::max_scn(), memtable->get_rec_scn()); LOG_INFO("remove ls"); - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id, true)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id)); } TEST_F(TestTableLockFlush, restore_tx_ctx) @@ -430,7 +430,7 @@ TEST_F(TestTableLockFlush, restore_tx_ctx) handle.reset(); LOG_INFO("restore_tx_ctx remove_ls"); - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id, true)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id)); } } // namespace storage diff --git a/mittest/multi_replica/env/ob_simple_replica.cpp b/mittest/multi_replica/env/ob_simple_replica.cpp index 26459c0d3..f1a60560b 100644 --- a/mittest/multi_replica/env/ob_simple_replica.cpp +++ b/mittest/multi_replica/env/ob_simple_replica.cpp @@ -405,10 +405,10 @@ int ObSimpleServerReplica::simple_close() SERVER_LOG(INFO, "safe quit need remove ls", K(MTL_ID()), K(ls_ids)); for (int i = 0; i < ls_ids.count(); i++) { if (ls_ids.at(i).id() > share::ObLSID::SYS_LS_ID) { - MTL(ObLSService*)->remove_ls(ls_ids.at(i), false); + MTL(ObLSService*)->remove_ls(ls_ids.at(i)); } } - MTL(ObLSService*)->remove_ls(share::ObLSID{share::ObLSID::SYS_LS_ID}, false); + MTL(ObLSService*)->remove_ls(share::ObLSID{share::ObLSID::SYS_LS_ID}); } }; diff --git a/mittest/simple_server/env/ob_simple_server.cpp b/mittest/simple_server/env/ob_simple_server.cpp index 47e5e75bc..d1aca0d52 100644 --- a/mittest/simple_server/env/ob_simple_server.cpp +++ b/mittest/simple_server/env/ob_simple_server.cpp @@ -404,10 +404,10 @@ int ObSimpleServer::simple_close() SERVER_LOG(INFO, "safe quit need remove ls", K(MTL_ID()), K(ls_ids)); for (int i = 0; i < ls_ids.count(); i++) { if (ls_ids.at(i).id() > share::ObLSID::SYS_LS_ID) { - MTL(ObLSService*)->remove_ls(ls_ids.at(i), false); + MTL(ObLSService*)->remove_ls(ls_ids.at(i)); } } - MTL(ObLSService*)->remove_ls(share::ObLSID{share::ObLSID::SYS_LS_ID}, false); + MTL(ObLSService*)->remove_ls(share::ObLSID{share::ObLSID::SYS_LS_ID}); } }; diff --git a/mittest/simple_server/test_tablet_autoinc_mgr.cpp b/mittest/simple_server/test_tablet_autoinc_mgr.cpp index e92f427ce..f11141523 100644 --- a/mittest/simple_server/test_tablet_autoinc_mgr.cpp +++ b/mittest/simple_server/test_tablet_autoinc_mgr.cpp @@ -198,7 +198,7 @@ TEST_F(TestTabletAutoincMgr, test_lob_tablet_autoinc_location_cache) } // remove source ls and clear src ls cache - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(src_ls_id, false)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(src_ls_id)); ASSERT_EQ(OB_SUCCESS, ls_location_service->erase_location_(GCONF.cluster_id, g_tenant_id, src_ls_id)); // insert lob diff --git a/src/logservice/ob_garbage_collector.cpp b/src/logservice/ob_garbage_collector.cpp index 161709d7b..29b236e10 100644 --- a/src/logservice/ob_garbage_collector.cpp +++ b/src/logservice/ob_garbage_collector.cpp @@ -1683,7 +1683,7 @@ void ObGarbageCollector::execute_gc_(ObGCCandidateArray &gc_candidates) CLOG_LOG(WARN, "failed to execute_pre_remove", K(tmp_ret), K(id), K_(self_addr)); } else if (OB_SUCCESS != (tmp_ret = switch_leader_adapter.remove_from_election_blacklist(id.id(), self_addr_))) { CLOG_LOG(WARN, "remove_from_election_blacklist failed", K(tmp_ret), K(id), K_(self_addr)); - } else if (OB_SUCCESS != (tmp_ret = ls_service_->remove_ls(id, false))) { + } else if (OB_SUCCESS != (tmp_ret = ls_service_->remove_ls(id))) { CLOG_LOG(WARN, "remove_ls failed", K(tmp_ret), K(id)); } else { CLOG_LOG(INFO, "remove_ls success", K(id), K(gc_reason)); diff --git a/src/storage/ls/ob_ls.cpp b/src/storage/ls/ob_ls.cpp index 6527a7f9c..f7246933f 100644 --- a/src/storage/ls/ob_ls.cpp +++ b/src/storage/ls/ob_ls.cpp @@ -77,6 +77,7 @@ namespace oceanbase using namespace share; using namespace logservice; using namespace transaction; +using namespace rootserver; namespace storage { @@ -122,8 +123,8 @@ int ObLS::init(const share::ObLSID &ls_id, { int ret = OB_SUCCESS; int tmp_ret = OB_SUCCESS; - logservice::ObLogService *logservice = MTL(logservice::ObLogService *); - transaction::ObTransService *txs_svr = MTL(transaction::ObTransService *); + ObLogService *logservice = MTL(ObLogService *); + ObTransService *txs_svr = MTL(ObTransService *); ObLSService *ls_service = MTL(ObLSService *); if (!ls_id.is_valid() || @@ -149,9 +150,8 @@ int ObLS::init(const share::ObLSID &ls_id, } else { rs_reporter_ = reporter; ls_freezer_.init(this); - transaction::ObTxPalfParam tx_palf_param(get_log_handler(), &dup_table_ls_handler_); + ObTxPalfParam tx_palf_param(get_log_handler(), &dup_table_ls_handler_); - // tx_table_.init() should after ls_table_svr.init() if (OB_FAIL(txs_svr->create_ls(ls_id, *this, &tx_palf_param, nullptr))) { LOG_WARN("create trans service failed.", K(ret), K(ls_id)); } else if (OB_FAIL(ls_tablet_svr_.init(this))) { @@ -207,147 +207,12 @@ int ObLS::init(const share::ObLSID &ls_id, LOG_WARN("failed to init block tx service", K(ret)); } else if (OB_FAIL(ls_transfer_status_.init(this))) { LOG_WARN("failed to init transfer status", K(ret)); + } else if (OB_FAIL(register_to_service_())) { + LOG_WARN("register to service failed", K(ret)); } else { - REGISTER_TO_LOGSERVICE(logservice::TRANS_SERVICE_LOG_BASE_TYPE, &ls_tx_svr_); - REGISTER_TO_LOGSERVICE(logservice::STORAGE_SCHEMA_LOG_BASE_TYPE, &ls_tablet_svr_); - REGISTER_TO_LOGSERVICE(logservice::TABLET_SEQ_SYNC_LOG_BASE_TYPE, &ls_sync_tablet_seq_handler_); - REGISTER_TO_LOGSERVICE(logservice::DDL_LOG_BASE_TYPE, &ls_ddl_log_handler_); - REGISTER_TO_LOGSERVICE(logservice::KEEP_ALIVE_LOG_BASE_TYPE, &keep_alive_ls_handler_); - REGISTER_TO_LOGSERVICE(logservice::GC_LS_LOG_BASE_TYPE, &gc_handler_); - REGISTER_TO_LOGSERVICE(logservice::OBJ_LOCK_GARBAGE_COLLECT_SERVICE_LOG_BASE_TYPE, &lock_table_); - REGISTER_TO_LOGSERVICE(logservice::RESERVED_SNAPSHOT_LOG_BASE_TYPE, &reserved_snapshot_clog_handler_); - REGISTER_TO_LOGSERVICE(logservice::MEDIUM_COMPACTION_LOG_BASE_TYPE, &medium_compaction_clog_handler_); - REGISTER_TO_LOGSERVICE(logservice::TRANSFER_HANDLER_LOG_BASE_TYPE, &transfer_handler_); - REGISTER_TO_LOGSERVICE(logservice::LS_BLOCK_TX_SERVICE_LOG_BASE_TYPE, &block_tx_service_); - - if (ls_id == IDS_LS) { - REGISTER_TO_LOGSERVICE(logservice::TIMESTAMP_LOG_BASE_TYPE, MTL(transaction::ObTimestampService *)); - REGISTER_TO_LOGSERVICE(logservice::TRANS_ID_LOG_BASE_TYPE, MTL(transaction::ObTransIDService *)); - if (is_user_tenant(tenant_id)) { - REGISTER_TO_RESTORESERVICE(logservice::STANDBY_TIMESTAMP_LOG_BASE_TYPE, MTL(transaction::ObStandbyTimestampService *)); - } else { - REGISTER_TO_LOGSERVICE(logservice::DAS_ID_LOG_BASE_TYPE, MTL(sql::ObDASIDService *)); - } - LOG_INFO("register id service success"); - } - - if (OB_SUCC(ret) && (ls_id == MAJOR_FREEZE_LS)) { - REGISTER_TO_LOGSERVICE(logservice::MAJOR_FREEZE_LOG_BASE_TYPE, MTL(rootserver::ObPrimaryMajorFreezeService *)); - LOG_INFO("register primary major freeze service complete", KR(ret)); - REGISTER_TO_RESTORESERVICE(logservice::MAJOR_FREEZE_LOG_BASE_TYPE, MTL(rootserver::ObRestoreMajorFreezeService *)); - LOG_INFO("register restore major freeze service complete", KR(ret)); - } - - if (ls_id == GAIS_LS && OB_SUCC(ret)) { - REGISTER_TO_LOGSERVICE(logservice::GAIS_LOG_BASE_TYPE, MTL(share::ObGlobalAutoIncService *)); - MTL(share::ObGlobalAutoIncService *)->set_cache_ls(this); - } - if (OB_SUCC(ret) && ls_id.is_sys_ls() && (is_meta_tenant(tenant_id) || is_sys_tenant(tenant_id))) { - REGISTER_TO_LOGSERVICE(logservice::BACKUP_TASK_SCHEDULER_LOG_BASE_TYPE, MTL(rootserver::ObBackupTaskScheduler *)); - REGISTER_TO_LOGSERVICE(logservice::BACKUP_DATA_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObBackupDataService *)); - REGISTER_TO_LOGSERVICE(logservice::BACKUP_CLEAN_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObBackupCleanService *)); - REGISTER_TO_LOGSERVICE(logservice::BACKUP_ARCHIVE_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObArchiveSchedulerService *)); - } - if (OB_SUCC(ret) && ls_id.is_sys_ls()) { - if (is_user_tenant(tenant_id)) { - //user - REGISTER_TO_LOGSERVICE(logservice::PRIMARY_LS_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObPrimaryLSService *)); - LOG_INFO("primary ls manager register to logservice success"); - REGISTER_TO_RESTORESERVICE(logservice::RECOVERY_LS_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObRecoveryLSService *)); - LOG_INFO("recovery ls manager register to restoreservice success"); - REGISTER_TO_LOGSERVICE(logservice::TENANT_TRANSFER_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObTenantTransferService *)); - LOG_INFO("tenant transfer service registre to logservice success"); - //only user tenant need balance - REGISTER_TO_LOGSERVICE(logservice::TENANT_BALANCE_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObTenantBalanceService *)); - LOG_INFO("tenant balance service register to logservice success"); - //only user tenant need balance - REGISTER_TO_LOGSERVICE(logservice::BALANCE_EXECUTE_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObBalanceTaskExecuteService *)); - LOG_INFO("balance execute service register to logservice success"); - - } else { - //meta and sys - REGISTER_TO_LOGSERVICE(logservice::COMMON_LS_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObCommonLSService *)); - LOG_INFO("common ls manager register to logservice success"); - //sys and meta tenant - REGISTER_TO_LOGSERVICE(logservice::RESTORE_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObRestoreService *)); - LOG_INFO("restore service register to logservice success"); - //only meta - } - } - - if (OB_SUCC(ret) && is_user_tenant(tenant_id) && ls_id.is_sys_ls()) { - // only user tenant need dump datadict - REGISTER_TO_LOGSERVICE(logservice::DATA_DICT_LOG_BASE_TYPE, MTL(datadict::ObDataDictService *)); - //only user table need recovery - REGISTER_TO_RESTORESERVICE(logservice::RECOVERY_LS_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObRecoveryLSService *)); - LOG_INFO("recovery ls manager registre to restoreservice success"); - REGISTER_TO_RESTORESERVICE(logservice::NET_STANDBY_TNT_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObCreateStandbyFromNetActor *)); - } - - if (OB_SUCC(ret) && OB_FAIL(ls_init_for_dup_table_())) { - LOG_WARN("pre init for dup_table_ls_handler_ failed", K(ret), K(get_ls_id())); - } - - if (OB_SUCC(ret) && !is_user_tenant(tenant_id) && ls_id.is_sys_ls()) { - //sys and meta tenant - REGISTER_TO_LOGSERVICE(logservice::RESTORE_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObRestoreService *)); - } - - if (OB_SUCC(ret) && is_meta_tenant(tenant_id) && ls_id.is_sys_ls()) { - REGISTER_TO_LOGSERVICE(logservice::SNAPSHOT_SCHEDULER_LOG_BASE_TYPE, MTL(rootserver::ObTenantSnapshotScheduler *)); - } - - if (OB_SUCC(ret) && !is_user_tenant(tenant_id) && ls_id.is_sys_ls()) { - //sys and meta tenant - REGISTER_TO_LOGSERVICE(logservice::CLONE_SCHEDULER_LOG_BASE_TYPE, MTL(rootserver::ObCloneScheduler *)); - } - -#ifdef OB_BUILD_ARBITRATION - if (OB_SUCC(ret) && !is_user_tenant(tenant_id) && ls_id.is_sys_ls()) { - REGISTER_TO_LOGSERVICE(logservice::ARBITRATION_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObArbitrationService *)); - LOG_INFO("arbitration service regist to logservice success"); - } -#endif - if (OB_SUCC(ret) && is_sys_tenant(tenant_id) && ls_id.is_sys_ls()) { - rootserver::ObIngressBWAllocService *ingress_service = GCTX.net_frame_->get_ingress_service(); - REGISTER_TO_LOGSERVICE(logservice::NET_ENDPOINT_INGRESS_LOG_BASE_TYPE, ingress_service); - LOG_INFO("net endpoint ingress regist to logservice success"); - } - if (OB_SUCC(ret) && is_sys_tenant(tenant_id) && ls_meta_.ls_id_.is_sys_ls()) { - REGISTER_TO_LOGSERVICE(logservice::WORKLOAD_REPOSITORY_SERVICE_LOG_BASE_TYPE, - GCTX.wr_service_); - } - - if (OB_SUCC(ret) && is_sys_tenant(tenant_id) && ls_id.is_sys_ls()) { - //sys tenant - REGISTER_TO_LOGSERVICE(logservice::HEARTBEAT_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObHeartbeatService *)); - LOG_INFO("heartbeat service is registered successfully"); - } - - if (OB_SUCC(ret) && is_user_tenant(tenant_id)) { - if (ls_id.is_sys_ls()) { - REGISTER_TO_LOGSERVICE(logservice::TTL_LOG_BASE_TYPE, MTL(table::ObTTLService *)); - LOG_INFO("register tenant ttl service complete", KR(ret)); - } else if (ls_id.is_user_ls()) { - if (OB_FAIL(tablet_ttl_mgr_.init(this))) { - LOG_WARN("fail to init tablet ttl manager", KR(ret)); - } else { - REGISTER_TO_LOGSERVICE(logservice::TTL_LOG_BASE_TYPE, &tablet_ttl_mgr_); - LOG_INFO("register tenant tablet ttl mgr complete", KR(ret)); - } - } - } - - if (OB_SUCC(ret) && ls_id.is_sys_ls() && (is_user_tenant(tenant_id) || is_sys_tenant(tenant_id))) { - REGISTER_TO_LOGSERVICE(logservice::MVIEW_MAINTENANCE_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObMViewMaintenanceService *)); - LOG_INFO("mview maintenance service is registered successfully", KR(ret)); - } - - if (OB_SUCC(ret)) { // don't delete it - election_priority_.set_ls_id(ls_id); - is_inited_ = true; - LOG_INFO("ls init success", K(ls_id)); - } + election_priority_.set_ls_id(ls_id); + is_inited_ = true; + LOG_INFO("ls init success", K(ls_id)); } // do some rollback work if (OB_FAIL(ret)) { @@ -360,7 +225,7 @@ int ObLS::init(const share::ObLSID &ls_id, int ObLS::ls_init_for_dup_table_() { int ret = OB_SUCCESS; - REGISTER_TO_LOGSERVICE(logservice::DUP_TABLE_LOG_BASE_TYPE, &dup_table_ls_handler_); + REGISTER_TO_LOGSERVICE(DUP_TABLE_LOG_BASE_TYPE, &dup_table_ls_handler_); dup_table_ls_handler_.default_init(get_ls_id(), get_log_handler()); return ret; } @@ -368,7 +233,7 @@ int ObLS::ls_init_for_dup_table_() int ObLS::ls_destory_for_dup_table_() { int ret = OB_SUCCESS; - UNREGISTER_FROM_LOGSERVICE(logservice::DUP_TABLE_LOG_BASE_TYPE, &dup_table_ls_handler_); + UNREGISTER_FROM_LOGSERVICE(DUP_TABLE_LOG_BASE_TYPE, &dup_table_ls_handler_); dup_table_ls_handler_.destroy(); return ret; } @@ -377,11 +242,30 @@ int ObLS::create_ls_inner_tablet(const lib::Worker::CompatMode compat_mode, const SCN &create_scn) { int ret = OB_SUCCESS; + int tmp_ret = OB_SUCCESS; if (OB_FAIL(tx_table_.create_tablet(compat_mode, create_scn))) { LOG_WARN("tx table create tablet failed", K(ret), K_(ls_meta), K(compat_mode), K(create_scn)); } else if (OB_FAIL(lock_table_.create_tablet(compat_mode, create_scn))) { LOG_WARN("lock table create tablet failed", K(ret), K_(ls_meta), K(compat_mode), K(create_scn)); } + if (OB_FAIL(ret)) { + do { + if (OB_TMP_FAIL(remove_ls_inner_tablet())) { + LOG_WARN("remove ls inner tablet failed", K(tmp_ret)); + } + } while (OB_TMP_FAIL(tmp_ret)); + } + return ret; +} + +int ObLS::remove_ls_inner_tablet() +{ + int ret = OB_SUCCESS; + if (OB_FAIL(tx_table_.remove_tablet())) { + LOG_WARN("tx table remove tablet failed", K(ret), K_(ls_meta)); + } else if (OB_FAIL(lock_table_.remove_tablet())) { + LOG_WARN("lock table remove tablet failed", K(ret), K_(ls_meta)); + } return ret; } @@ -396,7 +280,7 @@ int ObLS::create_ls(const share::ObTenantRole tenant_role, bool need_retry = false; static const int64_t SLEEP_TS = 100_ms; int64_t retry_cnt = 0; - logservice::ObLogService *logservice = MTL(logservice::ObLogService *); + ObLogService *logservice = MTL(ObLogService *); if (!is_inited_) { ret = OB_NOT_INIT; LOG_WARN("ls do not init", K(ret)); @@ -445,7 +329,7 @@ int ObLS::load_ls(const share::ObTenantRole &tenant_role, const bool allow_log_sync) { int ret = OB_SUCCESS; - logservice::ObLogService *logservice = MTL(logservice::ObLogService *); + ObLogService *logservice = MTL(ObLogService *); bool is_palf_exist = false; if (OB_FAIL(logservice->check_palf_exist(ls_meta_.ls_id_, is_palf_exist))) { @@ -474,7 +358,7 @@ int ObLS::remove_ls() { int ret = OB_SUCCESS; int tmp_ret = OB_SUCCESS; - logservice::ObLogService *logservice = MTL(logservice::ObLogService *); + ObLogService *logservice = MTL(ObLogService *); if (!is_inited_) { ret = OB_NOT_INIT; LOG_WARN("ls do not init", K(ret)); @@ -801,7 +685,7 @@ void ObLS::destroy() abort(); } } - transaction::ObTransService *txs_svr = MTL(transaction::ObTransService *); + ObTransService *txs_svr = MTL(ObTransService *); FLOG_INFO("ObLS destroy", K(this), K(*this), K(lbt())); if (running_state_.is_running()) { if (OB_TMP_FAIL(offline_(start_ts))) { @@ -816,133 +700,7 @@ void ObLS::destroy() LOG_WARN("failed to prepare for safe destroy", K(ret)); } } - UNREGISTER_FROM_LOGSERVICE(logservice::TRANS_SERVICE_LOG_BASE_TYPE, &ls_tx_svr_); - UNREGISTER_FROM_LOGSERVICE(logservice::STORAGE_SCHEMA_LOG_BASE_TYPE, &ls_tablet_svr_); - UNREGISTER_FROM_LOGSERVICE(logservice::TABLET_SEQ_SYNC_LOG_BASE_TYPE, &ls_sync_tablet_seq_handler_); - UNREGISTER_FROM_LOGSERVICE(logservice::DDL_LOG_BASE_TYPE, &ls_ddl_log_handler_); - UNREGISTER_FROM_LOGSERVICE(logservice::KEEP_ALIVE_LOG_BASE_TYPE, &keep_alive_ls_handler_); - UNREGISTER_FROM_LOGSERVICE(logservice::GC_LS_LOG_BASE_TYPE, &gc_handler_); - UNREGISTER_FROM_LOGSERVICE(logservice::OBJ_LOCK_GARBAGE_COLLECT_SERVICE_LOG_BASE_TYPE, &lock_table_); - UNREGISTER_FROM_LOGSERVICE(logservice::RESERVED_SNAPSHOT_LOG_BASE_TYPE, &reserved_snapshot_clog_handler_); - UNREGISTER_FROM_LOGSERVICE(logservice::MEDIUM_COMPACTION_LOG_BASE_TYPE, &medium_compaction_clog_handler_); - UNREGISTER_FROM_LOGSERVICE(logservice::TRANSFER_HANDLER_LOG_BASE_TYPE, &transfer_handler_); - UNREGISTER_FROM_LOGSERVICE(logservice::LS_BLOCK_TX_SERVICE_LOG_BASE_TYPE, &block_tx_service_); - - if (ls_meta_.ls_id_ == IDS_LS) { - MTL(transaction::ObTransIDService *)->reset_ls(); - MTL(transaction::ObTimestampService *)->reset_ls(); - MTL(sql::ObDASIDService *)->reset_ls(); - UNREGISTER_FROM_LOGSERVICE(logservice::TIMESTAMP_LOG_BASE_TYPE, MTL(transaction::ObTimestampService *)); - UNREGISTER_FROM_LOGSERVICE(logservice::TRANS_ID_LOG_BASE_TYPE, MTL(transaction::ObTransIDService *)); - if (is_user_tenant(MTL_ID())) { - UNREGISTER_FROM_RESTORESERVICE(logservice::STANDBY_TIMESTAMP_LOG_BASE_TYPE, MTL(transaction::ObStandbyTimestampService *)); - } else { - UNREGISTER_FROM_LOGSERVICE(logservice::DAS_ID_LOG_BASE_TYPE, MTL(sql::ObDASIDService *)); - } - } - if (ls_meta_.ls_id_ == MAJOR_FREEZE_LS) { - rootserver::ObRestoreMajorFreezeService *restore_major_freeze_service = MTL(rootserver::ObRestoreMajorFreezeService *); - UNREGISTER_FROM_RESTORESERVICE(logservice::MAJOR_FREEZE_LOG_BASE_TYPE, restore_major_freeze_service); - rootserver::ObPrimaryMajorFreezeService *primary_major_freeze_service = MTL(rootserver::ObPrimaryMajorFreezeService *); - UNREGISTER_FROM_LOGSERVICE(logservice::MAJOR_FREEZE_LOG_BASE_TYPE, primary_major_freeze_service); - } - if (ls_meta_.ls_id_ == GAIS_LS) { - UNREGISTER_FROM_LOGSERVICE(logservice::GAIS_LOG_BASE_TYPE, MTL(share::ObGlobalAutoIncService *)); - MTL(share::ObGlobalAutoIncService *)->set_cache_ls(nullptr); - } - if (ls_meta_.ls_id_.is_sys_ls()) { - if (is_user_tenant(MTL_ID())) { - rootserver::ObPrimaryLSService* ls_service = MTL(rootserver::ObPrimaryLSService*); - UNREGISTER_FROM_LOGSERVICE(logservice::PRIMARY_LS_SERVICE_LOG_BASE_TYPE, ls_service); - rootserver::ObRecoveryLSService* recovery_ls_service = MTL(rootserver::ObRecoveryLSService*); - UNREGISTER_FROM_RESTORESERVICE(logservice::RECOVERY_LS_SERVICE_LOG_BASE_TYPE, recovery_ls_service); - rootserver::ObTenantTransferService * transfer_service = MTL(rootserver::ObTenantTransferService*); - UNREGISTER_FROM_LOGSERVICE(logservice::TENANT_TRANSFER_SERVICE_LOG_BASE_TYPE, transfer_service); - rootserver::ObTenantBalanceService* balance_service = MTL(rootserver::ObTenantBalanceService*); - UNREGISTER_FROM_LOGSERVICE(logservice::TENANT_BALANCE_SERVICE_LOG_BASE_TYPE, balance_service); - rootserver::ObBalanceTaskExecuteService* balance_execute_service = MTL(rootserver::ObBalanceTaskExecuteService*); - UNREGISTER_FROM_LOGSERVICE(logservice::BALANCE_EXECUTE_SERVICE_LOG_BASE_TYPE, balance_execute_service); - - } else { - rootserver::ObCommonLSService *ls_service = MTL(rootserver::ObCommonLSService*); - UNREGISTER_FROM_LOGSERVICE(logservice::COMMON_LS_SERVICE_LOG_BASE_TYPE, ls_service); - rootserver::ObRestoreService * restore_service = MTL(rootserver::ObRestoreService*); - UNREGISTER_FROM_LOGSERVICE(logservice::RESTORE_SERVICE_LOG_BASE_TYPE, restore_service); - } - } - - if (ls_meta_.ls_id_.is_sys_ls() && !is_user_tenant(MTL_ID())) { - rootserver::ObBackupTaskScheduler* backup_task_scheduler = MTL(rootserver::ObBackupTaskScheduler*); - UNREGISTER_FROM_LOGSERVICE(logservice::BACKUP_TASK_SCHEDULER_LOG_BASE_TYPE, backup_task_scheduler); - rootserver::ObBackupDataService* backup_data_service = MTL(rootserver::ObBackupDataService*); - UNREGISTER_FROM_LOGSERVICE(logservice::BACKUP_DATA_SERVICE_LOG_BASE_TYPE, backup_data_service); - rootserver::ObBackupCleanService* backup_clean_service = MTL(rootserver::ObBackupCleanService*); - UNREGISTER_FROM_LOGSERVICE(logservice::BACKUP_CLEAN_SERVICE_LOG_BASE_TYPE, backup_clean_service); - rootserver::ObArchiveSchedulerService* backup_archive_service = MTL(rootserver::ObArchiveSchedulerService*); - UNREGISTER_FROM_LOGSERVICE(logservice::BACKUP_ARCHIVE_SERVICE_LOG_BASE_TYPE, backup_archive_service); - } - - - if (is_user_tenant(MTL_ID()) && ls_meta_.ls_id_.is_sys_ls()) { - UNREGISTER_FROM_LOGSERVICE(logservice::DATA_DICT_LOG_BASE_TYPE, MTL(datadict::ObDataDictService *)); - } - - if (OB_SUCC(ret) && is_user_tenant(MTL_ID()) && ls_meta_.ls_id_.is_sys_ls()) { - UNREGISTER_FROM_LOGSERVICE(logservice::DATA_DICT_LOG_BASE_TYPE, MTL(datadict::ObDataDictService *)); - rootserver::ObRecoveryLSService* ls_service = MTL(rootserver::ObRecoveryLSService*); - UNREGISTER_FROM_RESTORESERVICE(logservice::RECOVERY_LS_SERVICE_LOG_BASE_TYPE, ls_service); - - rootserver::ObCreateStandbyFromNetActor* net_standby_tnt_service = MTL(rootserver::ObCreateStandbyFromNetActor*); - UNREGISTER_FROM_RESTORESERVICE(logservice::NET_STANDBY_TNT_SERVICE_LOG_BASE_TYPE, net_standby_tnt_service); - } - - (void)ls_destory_for_dup_table_(); - - if (OB_SUCC(ret) && !is_user_tenant(MTL_ID()) && ls_meta_.ls_id_.is_sys_ls()) { - rootserver::ObRestoreService * restore_service = MTL(rootserver::ObRestoreService*); - UNREGISTER_FROM_LOGSERVICE(logservice::RESTORE_SERVICE_LOG_BASE_TYPE, restore_service); - } - if (is_sys_tenant(MTL_ID()) && ls_meta_.ls_id_.is_sys_ls()) { - rootserver::ObHeartbeatService * heartbeat_service = MTL(rootserver::ObHeartbeatService*); - UNREGISTER_FROM_LOGSERVICE(logservice::HEARTBEAT_SERVICE_LOG_BASE_TYPE, heartbeat_service); - } - if (is_meta_tenant(MTL_ID()) && ls_meta_.ls_id_.is_sys_ls()) { - rootserver::ObTenantSnapshotScheduler * snapshot_scheduler = MTL(rootserver::ObTenantSnapshotScheduler*); - UNREGISTER_FROM_LOGSERVICE(logservice::SNAPSHOT_SCHEDULER_LOG_BASE_TYPE, snapshot_scheduler); - } - if (!is_user_tenant(MTL_ID()) && ls_meta_.ls_id_.is_sys_ls()) { - rootserver::ObCloneScheduler * clone_scheduler = MTL(rootserver::ObCloneScheduler*); - UNREGISTER_FROM_LOGSERVICE(logservice::CLONE_SCHEDULER_LOG_BASE_TYPE, clone_scheduler); - } -#ifdef OB_BUILD_ARBITRATION - if (!is_user_tenant(MTL_ID()) && ls_meta_.ls_id_.is_sys_ls()) { - rootserver::ObArbitrationService * arbitration_service = MTL(rootserver::ObArbitrationService*); - UNREGISTER_FROM_LOGSERVICE(logservice::ARBITRATION_SERVICE_LOG_BASE_TYPE, arbitration_service); - } - -#endif - if (is_sys_tenant(MTL_ID()) && ls_meta_.ls_id_.is_sys_ls()) { - rootserver::ObIngressBWAllocService *ingress_service = GCTX.net_frame_->get_ingress_service(); - UNREGISTER_FROM_LOGSERVICE(logservice::NET_ENDPOINT_INGRESS_LOG_BASE_TYPE, ingress_service); - } - if (is_sys_tenant(MTL_ID()) && ls_meta_.ls_id_.is_sys_ls()) { - UNREGISTER_FROM_LOGSERVICE(logservice::WORKLOAD_REPOSITORY_SERVICE_LOG_BASE_TYPE, - GCTX.wr_service_); - } - - if (is_user_tenant(MTL_ID())) { - if (ls_meta_.ls_id_.is_sys_ls()) { - UNREGISTER_FROM_LOGSERVICE(logservice::TTL_LOG_BASE_TYPE, MTL(table::ObTTLService *)); - } else if (ls_meta_.ls_id_.is_user_ls()) { - UNREGISTER_FROM_LOGSERVICE(logservice::TTL_LOG_BASE_TYPE, tablet_ttl_mgr_); - tablet_ttl_mgr_.destroy(); - } - } - - if (ls_meta_.ls_id_.is_sys_ls() && (is_user_tenant(MTL_ID()) || is_sys_tenant(MTL_ID()))) { - UNREGISTER_FROM_LOGSERVICE(logservice::MVIEW_MAINTENANCE_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObMViewMaintenanceService *)); - } - + unregister_from_service_(); tx_table_.destroy(); lock_table_.destroy(); ls_tablet_svr_.destroy(); @@ -1163,6 +921,237 @@ int ObLS::online_advance_epoch_() return ret; } +int ObLS::register_common_service() +{ + int ret = OB_SUCCESS; + const ObLSID &ls_id = ls_meta_.ls_id_; + REGISTER_TO_LOGSERVICE(TRANS_SERVICE_LOG_BASE_TYPE, &ls_tx_svr_); + REGISTER_TO_LOGSERVICE(STORAGE_SCHEMA_LOG_BASE_TYPE, &ls_tablet_svr_); + REGISTER_TO_LOGSERVICE(TABLET_SEQ_SYNC_LOG_BASE_TYPE, &ls_sync_tablet_seq_handler_); + REGISTER_TO_LOGSERVICE(DDL_LOG_BASE_TYPE, &ls_ddl_log_handler_); + REGISTER_TO_LOGSERVICE(KEEP_ALIVE_LOG_BASE_TYPE, &keep_alive_ls_handler_); + REGISTER_TO_LOGSERVICE(GC_LS_LOG_BASE_TYPE, &gc_handler_); + REGISTER_TO_LOGSERVICE(OBJ_LOCK_GARBAGE_COLLECT_SERVICE_LOG_BASE_TYPE, &lock_table_); + REGISTER_TO_LOGSERVICE(RESERVED_SNAPSHOT_LOG_BASE_TYPE, &reserved_snapshot_clog_handler_); + REGISTER_TO_LOGSERVICE(MEDIUM_COMPACTION_LOG_BASE_TYPE, &medium_compaction_clog_handler_); + REGISTER_TO_LOGSERVICE(TRANSFER_HANDLER_LOG_BASE_TYPE, &transfer_handler_); + REGISTER_TO_LOGSERVICE(LS_BLOCK_TX_SERVICE_LOG_BASE_TYPE, &block_tx_service_); + + if (ls_id == IDS_LS) { + REGISTER_TO_LOGSERVICE(TIMESTAMP_LOG_BASE_TYPE, MTL(ObTimestampService *)); + REGISTER_TO_LOGSERVICE(TRANS_ID_LOG_BASE_TYPE, MTL(ObTransIDService *)); + } + if (ls_id == MAJOR_FREEZE_LS) { + REGISTER_TO_LOGSERVICE(MAJOR_FREEZE_LOG_BASE_TYPE, MTL(ObPrimaryMajorFreezeService *)); + REGISTER_TO_RESTORESERVICE(MAJOR_FREEZE_LOG_BASE_TYPE, MTL(ObRestoreMajorFreezeService *)); + } + if (ls_id == GAIS_LS) { + REGISTER_TO_LOGSERVICE(GAIS_LOG_BASE_TYPE, MTL(share::ObGlobalAutoIncService *)); + MTL(share::ObGlobalAutoIncService *)->set_cache_ls(this); + } + if (OB_SUCC(ret) && OB_FAIL(ls_init_for_dup_table_())) { + LOG_WARN("pre init for dup_table_ls_handler_ failed", K(ret), K(get_ls_id())); + } + return ret; +} + +int ObLS::register_sys_service() +{ + int ret = OB_SUCCESS; + const ObLSID &ls_id = ls_meta_.ls_id_; + const uint64_t tenant_id = MTL_ID(); + + if (ls_id == IDS_LS) { + REGISTER_TO_LOGSERVICE(DAS_ID_LOG_BASE_TYPE, MTL(sql::ObDASIDService *)); + } + if (ls_id.is_sys_ls()) { + REGISTER_TO_LOGSERVICE(BACKUP_TASK_SCHEDULER_LOG_BASE_TYPE, MTL(ObBackupTaskScheduler *)); + REGISTER_TO_LOGSERVICE(BACKUP_DATA_SERVICE_LOG_BASE_TYPE, MTL(ObBackupDataService *)); + REGISTER_TO_LOGSERVICE(BACKUP_CLEAN_SERVICE_LOG_BASE_TYPE, MTL(ObBackupCleanService *)); + REGISTER_TO_LOGSERVICE(BACKUP_ARCHIVE_SERVICE_LOG_BASE_TYPE, MTL(ObArchiveSchedulerService *)); + REGISTER_TO_LOGSERVICE(COMMON_LS_SERVICE_LOG_BASE_TYPE, MTL(ObCommonLSService *)); + REGISTER_TO_LOGSERVICE(RESTORE_SERVICE_LOG_BASE_TYPE, MTL(ObRestoreService *)); +#ifdef OB_BUILD_ARBITRATION + REGISTER_TO_LOGSERVICE(ARBITRATION_SERVICE_LOG_BASE_TYPE, MTL(rootserver::ObArbitrationService *)); +#endif + + REGISTER_TO_LOGSERVICE(CLONE_SCHEDULER_LOG_BASE_TYPE, MTL(ObCloneScheduler *)); + if (is_sys_tenant(tenant_id)) { + ObIngressBWAllocService *ingress_service = GCTX.net_frame_->get_ingress_service(); + REGISTER_TO_LOGSERVICE(NET_ENDPOINT_INGRESS_LOG_BASE_TYPE, ingress_service); + REGISTER_TO_LOGSERVICE(WORKLOAD_REPOSITORY_SERVICE_LOG_BASE_TYPE, GCTX.wr_service_); + REGISTER_TO_LOGSERVICE(HEARTBEAT_SERVICE_LOG_BASE_TYPE, MTL(ObHeartbeatService *)); + REGISTER_TO_LOGSERVICE(MVIEW_MAINTENANCE_SERVICE_LOG_BASE_TYPE, MTL(ObMViewMaintenanceService *)); + } + if (is_meta_tenant(tenant_id)) { + REGISTER_TO_LOGSERVICE(SNAPSHOT_SCHEDULER_LOG_BASE_TYPE, MTL(ObTenantSnapshotScheduler *)); + } + } + return ret; +} + +int ObLS::register_user_service() +{ + int ret = OB_SUCCESS; + const ObLSID &ls_id = ls_meta_.ls_id_; + + if (ls_id == IDS_LS) { + REGISTER_TO_RESTORESERVICE(STANDBY_TIMESTAMP_LOG_BASE_TYPE, MTL(ObStandbyTimestampService *)); + } + if (ls_id.is_sys_ls()) { + REGISTER_TO_LOGSERVICE(PRIMARY_LS_SERVICE_LOG_BASE_TYPE, MTL(ObPrimaryLSService *)); + REGISTER_TO_RESTORESERVICE(RECOVERY_LS_SERVICE_LOG_BASE_TYPE, MTL(ObRecoveryLSService *)); + REGISTER_TO_LOGSERVICE(TENANT_TRANSFER_SERVICE_LOG_BASE_TYPE, MTL(ObTenantTransferService *)); + REGISTER_TO_LOGSERVICE(TENANT_BALANCE_SERVICE_LOG_BASE_TYPE, MTL(ObTenantBalanceService *)); + REGISTER_TO_LOGSERVICE(BALANCE_EXECUTE_SERVICE_LOG_BASE_TYPE, MTL(ObBalanceTaskExecuteService *)); + REGISTER_TO_LOGSERVICE(DATA_DICT_LOG_BASE_TYPE, MTL(datadict::ObDataDictService *)); + REGISTER_TO_RESTORESERVICE(RECOVERY_LS_SERVICE_LOG_BASE_TYPE, MTL(ObRecoveryLSService *)); + REGISTER_TO_RESTORESERVICE(NET_STANDBY_TNT_SERVICE_LOG_BASE_TYPE, MTL(ObCreateStandbyFromNetActor *)); + REGISTER_TO_LOGSERVICE(TTL_LOG_BASE_TYPE, MTL(table::ObTTLService *)); + REGISTER_TO_LOGSERVICE(MVIEW_MAINTENANCE_SERVICE_LOG_BASE_TYPE, MTL(ObMViewMaintenanceService *)); + } + + if (ls_id.is_user_ls()) { + if (OB_SUCC(ret)) { + if (OB_FAIL(tablet_ttl_mgr_.init(this))) { + LOG_WARN("fail to init tablet ttl manager", KR(ret)); + } else { + REGISTER_TO_LOGSERVICE(TTL_LOG_BASE_TYPE, &tablet_ttl_mgr_); + } + } + } + + return ret; +} + +int ObLS::register_to_service_() +{ + int ret = OB_SUCCESS; + const ObLSID &ls_id = ls_meta_.ls_id_; + const uint64_t tenant_id = MTL_ID(); + if (OB_FAIL(register_common_service())) { + LOG_WARN("common tenant register failed", K(ret), K(ls_id)); + } else if (is_user_tenant(tenant_id) && OB_FAIL(register_user_service())) { + LOG_WARN("user tenant register failed", K(ret), K(ls_id)); + } else if (!is_user_tenant(tenant_id) && OB_FAIL(register_sys_service())) { + LOG_WARN("no user tenant register failed", K(ret), K(ls_id)); + } + + return ret; +} + +void ObLS::unregister_common_service_() +{ + UNREGISTER_FROM_LOGSERVICE(TRANS_SERVICE_LOG_BASE_TYPE, &ls_tx_svr_); + UNREGISTER_FROM_LOGSERVICE(STORAGE_SCHEMA_LOG_BASE_TYPE, &ls_tablet_svr_); + UNREGISTER_FROM_LOGSERVICE(TABLET_SEQ_SYNC_LOG_BASE_TYPE, &ls_sync_tablet_seq_handler_); + UNREGISTER_FROM_LOGSERVICE(DDL_LOG_BASE_TYPE, &ls_ddl_log_handler_); + UNREGISTER_FROM_LOGSERVICE(KEEP_ALIVE_LOG_BASE_TYPE, &keep_alive_ls_handler_); + UNREGISTER_FROM_LOGSERVICE(GC_LS_LOG_BASE_TYPE, &gc_handler_); + UNREGISTER_FROM_LOGSERVICE(OBJ_LOCK_GARBAGE_COLLECT_SERVICE_LOG_BASE_TYPE, &lock_table_); + UNREGISTER_FROM_LOGSERVICE(RESERVED_SNAPSHOT_LOG_BASE_TYPE, &reserved_snapshot_clog_handler_); + UNREGISTER_FROM_LOGSERVICE(MEDIUM_COMPACTION_LOG_BASE_TYPE, &medium_compaction_clog_handler_); + UNREGISTER_FROM_LOGSERVICE(TRANSFER_HANDLER_LOG_BASE_TYPE, &transfer_handler_); + UNREGISTER_FROM_LOGSERVICE(LS_BLOCK_TX_SERVICE_LOG_BASE_TYPE, &block_tx_service_); + if (ls_meta_.ls_id_ == IDS_LS) { + MTL(ObTransIDService *)->reset_ls(); + MTL(ObTimestampService *)->reset_ls(); + UNREGISTER_FROM_LOGSERVICE(TIMESTAMP_LOG_BASE_TYPE, MTL(ObTimestampService *)); + UNREGISTER_FROM_LOGSERVICE(TRANS_ID_LOG_BASE_TYPE, MTL(ObTransIDService *)); + } + if (ls_meta_.ls_id_ == MAJOR_FREEZE_LS) { + ObRestoreMajorFreezeService *restore_major_freeze_service = MTL(ObRestoreMajorFreezeService *); + UNREGISTER_FROM_RESTORESERVICE(MAJOR_FREEZE_LOG_BASE_TYPE, restore_major_freeze_service); + ObPrimaryMajorFreezeService *primary_major_freeze_service = MTL(ObPrimaryMajorFreezeService *); + UNREGISTER_FROM_LOGSERVICE(MAJOR_FREEZE_LOG_BASE_TYPE, primary_major_freeze_service); + } + if (ls_meta_.ls_id_ == GAIS_LS) { + UNREGISTER_FROM_LOGSERVICE(GAIS_LOG_BASE_TYPE, MTL(share::ObGlobalAutoIncService *)); + MTL(share::ObGlobalAutoIncService *)->set_cache_ls(nullptr); + } + (void)ls_destory_for_dup_table_(); +} + +void ObLS::unregister_sys_service_() +{ + if (ls_meta_.ls_id_ == IDS_LS) { + MTL(sql::ObDASIDService *)->reset_ls(); + UNREGISTER_FROM_LOGSERVICE(DAS_ID_LOG_BASE_TYPE, MTL(sql::ObDASIDService *)); + } + if (ls_meta_.ls_id_.is_sys_ls()) { + ObBackupTaskScheduler* backup_task_scheduler = MTL(ObBackupTaskScheduler*); + UNREGISTER_FROM_LOGSERVICE(BACKUP_TASK_SCHEDULER_LOG_BASE_TYPE, backup_task_scheduler); + ObBackupDataService* backup_data_service = MTL(ObBackupDataService*); + UNREGISTER_FROM_LOGSERVICE(BACKUP_DATA_SERVICE_LOG_BASE_TYPE, backup_data_service); + ObBackupCleanService* backup_clean_service = MTL(ObBackupCleanService*); + UNREGISTER_FROM_LOGSERVICE(BACKUP_CLEAN_SERVICE_LOG_BASE_TYPE, backup_clean_service); + ObArchiveSchedulerService* backup_archive_service = MTL(ObArchiveSchedulerService*); + UNREGISTER_FROM_LOGSERVICE(BACKUP_ARCHIVE_SERVICE_LOG_BASE_TYPE, backup_archive_service); + ObCommonLSService *ls_service = MTL(ObCommonLSService*); + UNREGISTER_FROM_LOGSERVICE(COMMON_LS_SERVICE_LOG_BASE_TYPE, ls_service); + ObRestoreService * restore_service = MTL(ObRestoreService*); + UNREGISTER_FROM_LOGSERVICE(RESTORE_SERVICE_LOG_BASE_TYPE, restore_service); +#ifdef OB_BUILD_ARBITRATION + rootserver::ObArbitrationService * arbitration_service = MTL(rootserver::ObArbitrationService*); + UNREGISTER_FROM_LOGSERVICE(ARBITRATION_SERVICE_LOG_BASE_TYPE, arbitration_service); +#endif + ObCloneScheduler * clone_scheduler = MTL(ObCloneScheduler*); + UNREGISTER_FROM_LOGSERVICE(CLONE_SCHEDULER_LOG_BASE_TYPE, clone_scheduler); + if (is_sys_tenant(MTL_ID())) { + ObIngressBWAllocService *ingress_service = GCTX.net_frame_->get_ingress_service(); + UNREGISTER_FROM_LOGSERVICE(NET_ENDPOINT_INGRESS_LOG_BASE_TYPE, ingress_service); + UNREGISTER_FROM_LOGSERVICE(WORKLOAD_REPOSITORY_SERVICE_LOG_BASE_TYPE, GCTX.wr_service_); + ObHeartbeatService * heartbeat_service = MTL(ObHeartbeatService*); + UNREGISTER_FROM_LOGSERVICE(HEARTBEAT_SERVICE_LOG_BASE_TYPE, heartbeat_service); + UNREGISTER_FROM_LOGSERVICE(MVIEW_MAINTENANCE_SERVICE_LOG_BASE_TYPE, MTL(ObMViewMaintenanceService *)); + } + if (is_meta_tenant(MTL_ID())) { + ObTenantSnapshotScheduler * snapshot_scheduler = MTL(ObTenantSnapshotScheduler*); + UNREGISTER_FROM_LOGSERVICE(SNAPSHOT_SCHEDULER_LOG_BASE_TYPE, snapshot_scheduler); + } + } +} + +void ObLS::unregister_user_service_() +{ + if (ls_meta_.ls_id_ == IDS_LS) { + UNREGISTER_FROM_RESTORESERVICE(STANDBY_TIMESTAMP_LOG_BASE_TYPE, MTL(ObStandbyTimestampService *)); + } + if (ls_meta_.ls_id_.is_sys_ls()) { + ObPrimaryLSService* ls_service = MTL(ObPrimaryLSService*); + UNREGISTER_FROM_LOGSERVICE(PRIMARY_LS_SERVICE_LOG_BASE_TYPE, ls_service); + ObRecoveryLSService* recovery_ls_service = MTL(ObRecoveryLSService*); + UNREGISTER_FROM_RESTORESERVICE(RECOVERY_LS_SERVICE_LOG_BASE_TYPE, recovery_ls_service); + ObTenantTransferService * transfer_service = MTL(ObTenantTransferService*); + UNREGISTER_FROM_LOGSERVICE(TENANT_TRANSFER_SERVICE_LOG_BASE_TYPE, transfer_service); + ObTenantBalanceService* balance_service = MTL(ObTenantBalanceService*); + UNREGISTER_FROM_LOGSERVICE(TENANT_BALANCE_SERVICE_LOG_BASE_TYPE, balance_service); + ObBalanceTaskExecuteService* balance_execute_service = MTL(ObBalanceTaskExecuteService*); + UNREGISTER_FROM_LOGSERVICE(BALANCE_EXECUTE_SERVICE_LOG_BASE_TYPE, balance_execute_service); + UNREGISTER_FROM_LOGSERVICE(DATA_DICT_LOG_BASE_TYPE, MTL(datadict::ObDataDictService *)); + ObRecoveryLSService* recover_ls_service = MTL(ObRecoveryLSService*); + UNREGISTER_FROM_RESTORESERVICE(RECOVERY_LS_SERVICE_LOG_BASE_TYPE, recover_ls_service); + ObCreateStandbyFromNetActor* net_standby_tnt_service = MTL(ObCreateStandbyFromNetActor*); + UNREGISTER_FROM_RESTORESERVICE(NET_STANDBY_TNT_SERVICE_LOG_BASE_TYPE, net_standby_tnt_service); + UNREGISTER_FROM_LOGSERVICE(TTL_LOG_BASE_TYPE, MTL(table::ObTTLService *)); + UNREGISTER_FROM_LOGSERVICE(MVIEW_MAINTENANCE_SERVICE_LOG_BASE_TYPE, MTL(ObMViewMaintenanceService *)); + } + if (ls_meta_.ls_id_.is_user_ls()) { + UNREGISTER_FROM_LOGSERVICE(TTL_LOG_BASE_TYPE, tablet_ttl_mgr_); + tablet_ttl_mgr_.destroy(); + } +} + +void ObLS::unregister_from_service_() +{ + unregister_common_service_(); + if (is_user_tenant(MTL_ID())) { + unregister_user_service_(); + } else { + unregister_sys_service_(); + } +} + int ObLS::online() { int64_t read_lock = 0; @@ -1560,10 +1549,10 @@ int ObLS::tablet_transfer_in(const ObTabletID &tablet_id) int64_t write_lock = LSLOCKSTORAGESTATE; ObLSLockGuard lock_myself(this, lock_, read_lock, write_lock); // make sure there is no block on going. - logservice::LSGCState gc_state = logservice::LSGCState::INVALID_LS_GC_STATE; + LSGCState gc_state = LSGCState::INVALID_LS_GC_STATE; if (OB_FAIL(get_gc_state(gc_state))) { LOG_WARN("get_gc_state failed", K(ret), K(get_ls_id())); - } else if (OB_UNLIKELY(logservice::LSGCState::LS_BLOCKED == gc_state)) { + } else if (OB_UNLIKELY(LSGCState::LS_BLOCKED == gc_state)) { ret = OB_OP_NOT_ALLOW; LOG_WARN("ls is blocked, cannot transfer in", K(ret), K(tablet_id)); } else { @@ -2307,7 +2296,7 @@ int ObLS::update_ls_meta(const bool update_restore_status, int ObLS::diagnose(DiagnoseInfo &info) const { int ret = OB_SUCCESS; - logservice::ObLogService *log_service = MTL(logservice::ObLogService *); + ObLogService *log_service = MTL(ObLogService *); share::ObLSID ls_id = get_ls_id(); if (IS_NOT_INIT) { ret = OB_NOT_INIT; @@ -2335,8 +2324,8 @@ int ObLS::diagnose(DiagnoseInfo &info) const #endif } else if (info.is_role_sync()) { // 角色同步时不需要诊断role change service - info.rc_diagnose_info_.state_ = logservice::TakeOverState::TAKE_OVER_FINISH; - info.rc_diagnose_info_.log_type_ = logservice::ObLogBaseType::INVALID_LOG_BASE_TYPE; + info.rc_diagnose_info_.state_ = TakeOverState::TAKE_OVER_FINISH; + info.rc_diagnose_info_.log_type_ = ObLogBaseType::INVALID_LOG_BASE_TYPE; } else if (OB_FAIL(log_service->diagnose_role_change(info.rc_diagnose_info_))) { // election, palf, log handler角色不统一时可能出现无主 STORAGE_LOG(WARN, "diagnose rc service failed", K(ret), K(ls_id)); @@ -2431,13 +2420,13 @@ int ObLS::set_restore_status( return ret; } -int ObLS::set_gc_state(const logservice::LSGCState &gc_state) +int ObLS::set_gc_state(const LSGCState &gc_state) { SCN invalid_scn; return set_gc_state(gc_state, invalid_scn); } -int ObLS::set_gc_state(const logservice::LSGCState &gc_state, const share::SCN &offline_scn) +int ObLS::set_gc_state(const LSGCState &gc_state, const share::SCN &offline_scn) { int ret = OB_SUCCESS; if (IS_NOT_INIT) { @@ -2475,12 +2464,12 @@ bool ObLS::is_in_gc() { int bret = false; int ret = OB_SUCCESS; - logservice::LSGCState state; + LSGCState state; if (OB_FAIL(get_gc_state(state))) { LOG_WARN("get ls gc state fail", K(state)); - } else if (logservice::LSGCState::INVALID_LS_GC_STATE == state) { + } else if (LSGCState::INVALID_LS_GC_STATE == state) { LOG_WARN("invalid ls gc state", K(state)); - } else if (state != logservice::LSGCState::NORMAL) { + } else if (state != LSGCState::NORMAL) { bret = true; } return bret; diff --git a/src/storage/ls/ob_ls.h b/src/storage/ls/ob_ls.h index f2fc796f3..a12f921f0 100644 --- a/src/storage/ls/ob_ls.h +++ b/src/storage/ls/ob_ls.h @@ -340,6 +340,7 @@ public: // create all the inner tablet. int create_ls_inner_tablet(const lib::Worker::CompatMode compat_mode, const share::SCN &create_scn); + int remove_ls_inner_tablet(); // get the meta package of ls: ObLSMeta, PalfBaseInfo // @param[in] check_archive, if need check archive, @@ -407,6 +408,15 @@ private: ObTabletHandle &handle); int offline_advance_epoch_(); int online_advance_epoch_(); + int register_to_service_(); + int register_common_service(); + int register_sys_service(); + int register_user_service(); + + void unregister_from_service_(); + void unregister_common_service_(); + void unregister_sys_service_(); + void unregister_user_service_(); public: // ObLSMeta interface: int update_ls_meta(const bool update_restore_status, diff --git a/src/storage/tablelock/ob_lock_table.cpp b/src/storage/tablelock/ob_lock_table.cpp index a0ebbc049..a14f215b4 100644 --- a/src/storage/tablelock/ob_lock_table.cpp +++ b/src/storage/tablelock/ob_lock_table.cpp @@ -359,8 +359,12 @@ int ObLockTable::remove_tablet() { int ret = OB_SUCCESS; const share::ObLSID &ls_id = parent_->get_ls_id(); - if (OB_FAIL(parent_->remove_ls_inner_tablet(ls_id, LS_LOCK_TABLET))) { + if (IS_NOT_INIT) { + LOG_WARN("lock table does not inited, remove do nothing"); + } else if (OB_FAIL(parent_->remove_ls_inner_tablet(ls_id, LS_LOCK_TABLET))) { LOG_WARN("failed to remove ls inner tablet", K(ret), K(ls_id), K(LS_LOCK_TABLET)); + ob_usleep(1000 * 1000); + ob_abort(); } return ret; } diff --git a/src/storage/tx_storage/ob_ls_service.cpp b/src/storage/tx_storage/ob_ls_service.cpp index 3e17741ee..748eafab8 100644 --- a/src/storage/tx_storage/ob_ls_service.cpp +++ b/src/storage/tx_storage/ob_ls_service.cpp @@ -43,6 +43,7 @@ using namespace lib; using namespace logservice; namespace storage { +#define OB_BREAK_FAIL(statement) (OB_UNLIKELY(((++process_point) && break_point == process_point && OB_FAIL(OB_BREAK_BY_TEST)) || OB_FAIL(statement))) static inline void prepare_palf_base_info(const obrpc::ObCreateLSArg &arg, palf::PalfBaseInfo &palf_base_info) @@ -139,61 +140,23 @@ int ObLSService::stop() // remove all the ls from ls map and push it into the // safe to destroy thread. common::ObSharedGuard ls_iter; - ObLSSafeDestroyTask *task = nullptr; ObLSHandle handle; ObLS *ls = nullptr; const bool remove_from_disk = false; - static const int64_t SLEEP_TS = 100_ms; lib::ObMutexGuard change_guard(change_lock_); if (OB_FAIL(get_ls_iter(ls_iter, ObLSGetMod::TXSTORAGE_MOD))) { LOG_WARN("failed to get ls iter", K(ret)); } else { while (OB_SUCC(ret)) { - task = nullptr; if (OB_FAIL(ls_iter->get_next(ls))) { if (OB_ITER_END != ret) { LOG_ERROR("fail to get next ls", K(ret)); } - } else if (nullptr == ls) { - ret = OB_ERR_UNEXPECTED; - LOG_ERROR("ls is null", K(ret)); - } else if (OB_FAIL(ls->offline())) { - LOG_WARN("ls offline failed", K(ret), K(ls->get_ls_id()), KP(ls)); - } else if (OB_FAIL(ls->stop())) { - LOG_WARN("stop ls failed", K(ret), KP(ls), K(ls->get_ls_id())); - } else if (FALSE_IT(ls->wait())) { } else if (OB_FAIL(handle.set_ls(ls_map_, *ls, ObLSGetMod::TXSTORAGE_MOD))) { LOG_WARN("get ls handle failed", K(ret), KPC(ls)); - } else { - ObGarbageCollector *gc_service = MTL(logservice::ObGarbageCollector *); - ObLSLockGuard lock_ls(ls); - if (OB_ISNULL(gc_service)) { - ret = OB_ERR_UNEXPECTED; - LOG_WARN("gc service is null", K(ret)); - } else if (OB_ISNULL(task = (ObLSSafeDestroyTask*)ob_malloc(sizeof(ObLSSafeDestroyTask), - "LSSafeDestroy"))) { - ret = OB_ALLOCATE_MEMORY_FAILED; - LOG_WARN("alloc memory failed", K(ret)); - } else if (FALSE_IT(task = new(task) ObLSSafeDestroyTask())) { - } else if (OB_FAIL(task->init(MTL_ID(), - handle, - this))) { - LOG_WARN("init safe destroy task failed", K(ret)); - } else { - remove_ls_(ls, remove_from_disk); - // try until success. - while (OB_FAIL(gc_service->add_safe_destroy_task(*task))) { - if (REACH_TIME_INTERVAL(1_min)) { // every minute - LOG_WARN("add safe destroy task failed, retry", K(ret), KPC(task)); - } - ob_usleep(SLEEP_TS); - } - } - if (OB_FAIL(ret) && OB_NOT_NULL(task)) { - task->~ObLSSafeDestroyTask(); - ob_free(task); - } + } else if (OB_FAIL(safe_remove_ls_(handle, remove_from_disk))) { + LOG_WARN("safe remove ls failed", K(ret), KPC(ls)); } } if (OB_ITER_END == ret) { @@ -910,15 +873,13 @@ int ObLSService::get_ls( return ret; } -int ObLSService::remove_ls( - const share::ObLSID &ls_id, - const bool is_replay) +int ObLSService::remove_ls(const share::ObLSID &ls_id) { int ret = OB_SUCCESS; int tmp_ret = OB_SUCCESS; int64_t abs_timeout_ts = INT64_MAX; ObLSHandle handle; - ObLS *ls = NULL; + const bool remove_from_disk = true; if (IS_NOT_INIT) { ret = OB_NOT_INIT; LOG_WARN("not init", K(ret)); @@ -949,48 +910,9 @@ int ObLSService::remove_ls( } else { LOG_WARN("get log stream failed", K(ret), K(ls_id)); } - } else if (OB_ISNULL(ls = handle.get_ls())) { - ret = OB_ERR_UNEXPECTED; - LOG_ERROR("log stream is null, unexpected error", K(ls_id)); // ls leader gc must has block tx start, gracefully kill tx and write offline log before here. - } else if (OB_FAIL(ls->offline())) { - LOG_WARN("ls offline failed", K(ret), K(ls_id), KP(ls)); - } else if (OB_FAIL(ls->stop())) { - LOG_WARN("stop ls failed", K(ret), KP(ls), K(ls_id)); - } else if (FALSE_IT(ls->wait())) { - } else { - ObLSSafeDestroyTask *task = nullptr; - static const int64_t SLEEP_TS = 100_ms; - ObLSLockGuard lock_ls(ls); - if (OB_ISNULL(task = (ObLSSafeDestroyTask*)ob_malloc(sizeof(ObLSSafeDestroyTask), - "LSSafeDestroy"))) { - ret = OB_ALLOCATE_MEMORY_FAILED; - LOG_WARN("alloc memory failed", K(ret)); - } else if (FALSE_IT(task = new(task) ObLSSafeDestroyTask())) { - } else if (OB_FAIL(ls->set_remove_state())) { - LOG_WARN("ls set remove state failed", KR(ret), K(ls_id)); - // set ls to remove state and prevent slog write - } else if(!is_replay && - OB_FAIL(write_remove_ls_slog_(ls_id))) { - LOG_WARN("fail to write remove ls slog", K(ret)); - } else if (OB_FAIL(task->init(MTL_ID(), - handle, - this))) { - LOG_WARN("init safe destroy task failed", K(ret)); - } else { - remove_ls_(ls); - // try until success. - while (OB_FAIL(gc_service->add_safe_destroy_task(*task))) { - if (REACH_TIME_INTERVAL(1_min)) { // every minute - LOG_WARN("add safe destroy task failed, retry", K(ret), KPC(task)); - } - ob_usleep(SLEEP_TS); - } - } - if (OB_FAIL(ret) && OB_NOT_NULL(task)) { - task->~ObLSSafeDestroyTask(); - ob_free(task); - } + } else if (OB_FAIL(safe_remove_ls_(handle, remove_from_disk))) { + LOG_WARN("safe remove ls failed", K(ret), K(ls_id), K(handle)); } // report after remove if (OB_SUCC(ret)) { @@ -1006,7 +928,57 @@ int ObLSService::remove_ls( } } - FLOG_INFO("remove_ls finish", K(ret), K(ls_id), KPC(ls), K(is_replay), K(abs_timeout_ts)); + FLOG_INFO("remove_ls finish", K(ret), K(ls_id), K(handle), K(abs_timeout_ts)); + return ret; +} + +int ObLSService::safe_remove_ls_(ObLSHandle handle, const bool remove_from_disk) +{ + int ret = OB_SUCCESS; + ObLS *ls = NULL; + if (OB_ISNULL(ls = handle.get_ls())) { + ret = OB_ERR_UNEXPECTED; + LOG_ERROR("log stream is null, unexpected error"); + } else if (OB_FAIL(ls->offline())) { + LOG_WARN("ls offline failed", K(ret), KP(ls)); + } else if (OB_FAIL(ls->stop())) { + LOG_WARN("stop ls failed", K(ret), KP(ls)); + } else if (FALSE_IT(ls->wait())) { + } else { + ObGarbageCollector *gc_service = MTL(logservice::ObGarbageCollector *); + ObLSSafeDestroyTask *task = nullptr; + const ObLSID &ls_id = ls->get_ls_id(); + static const int64_t SLEEP_TS = 100_ms; + ObLSLockGuard lock_ls(ls); + if (OB_ISNULL(task = (ObLSSafeDestroyTask*)ob_malloc(sizeof(ObLSSafeDestroyTask), + "LSSafeDestroy"))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_WARN("alloc memory failed", K(ret)); + } else if (FALSE_IT(task = new(task) ObLSSafeDestroyTask())) { + } else if (remove_from_disk && OB_FAIL(ls->set_remove_state())) { + LOG_WARN("ls set remove state failed", KR(ret), K(ls_id)); + // set ls to remove state and prevent slog write + } else if(remove_from_disk && OB_FAIL(write_remove_ls_slog_(ls_id))) { + LOG_WARN("fail to write remove ls slog", K(ret)); + } else if (OB_FAIL(task->init(MTL_ID(), + handle, + this))) { + LOG_WARN("init safe destroy task failed", K(ret)); + } else { + remove_ls_(ls, remove_from_disk); + // try until success. + while (OB_FAIL(gc_service->add_safe_destroy_task(*task))) { + if (REACH_TIME_INTERVAL(1_min)) { // every minute + LOG_WARN("add safe destroy task failed, retry", K(ret), KPC(task)); + } + ob_usleep(SLEEP_TS); + } + } + if (OB_FAIL(ret) && OB_NOT_NULL(task)) { + task->~ObLSSafeDestroyTask(); + ob_free(task); + } + } return ret; } @@ -1046,6 +1018,7 @@ int ObLSService::create_ls_(const ObCreateLSCommonArg &arg, bool need_retry = true; bool ls_exist = false; bool waiting_destroy = false; + int64_t process_point = 0; if (IS_NOT_INIT) { ret = OB_NOT_INIT; @@ -1053,7 +1026,7 @@ int ObLSService::create_ls_(const ObCreateLSCommonArg &arg, } else if (OB_UNLIKELY(!ObServerCheckpointSlogHandler::get_instance().is_started())) { ret = OB_NOT_RUNNING; LOG_WARN("ls service does not service before slog replay finished", K(ret)); - } else if (OB_FAIL(ObShareUtil::get_abs_timeout(DEFAULT_LOCK_TIMEOUT /* default timeout */, + } else if (OB_BREAK_FAIL(ObShareUtil::get_abs_timeout(DEFAULT_LOCK_TIMEOUT /* default timeout */, abs_timeout_ts))) { LOG_WARN("get timeout ts failed", KR(ret)); } else { @@ -1061,87 +1034,64 @@ int ObLSService::create_ls_(const ObCreateLSCommonArg &arg, if (OB_UNLIKELY(!is_running_)) { ret = OB_NOT_RUNNING; LOG_WARN("ls service is not running.", K(ret)); - } else if (OB_FAIL(change_guard.get_ret())) { + } else if (OB_BREAK_FAIL(change_guard.get_ret())) { LOG_WARN("lock failed, try again later", K(ret)); ret = OB_EAGAIN; - } else if (OB_FAIL(check_ls_exist(arg.ls_id_, ls_exist))) { + } else if (OB_BREAK_FAIL(check_ls_exist(arg.ls_id_, ls_exist))) { LOG_WARN("check ls exist failed", K(ret), K(arg.ls_id_)); } else if (ls_exist) { ret = OB_LS_EXIST; LOG_WARN("ls exist, cannot create ls now", K(ret), K(arg.ls_id_)); - } else if (OB_FAIL(check_ls_waiting_safe_destroy(arg.ls_id_, - waiting_destroy))) { + } else if (OB_BREAK_FAIL(check_ls_waiting_safe_destroy(arg.ls_id_, + waiting_destroy))) { LOG_WARN("check ls waiting safe destroy failed", K(ret), K(arg.ls_id_)); } else if (waiting_destroy) { ret = OB_LS_WAITING_SAFE_DESTROY; LOG_WARN("ls waiting for destroy, need retry later", K(ret), K(arg.ls_id_)); - } else if (OB_FAIL(check_tenant_ls_num_())) { + } else if (OB_BREAK_FAIL(check_tenant_ls_num_())) { LOG_WARN("too many ls", K(ret)); - } else if (OB_FAIL(inner_create_ls_(arg.ls_id_, - arg.migration_status_, - arg.restore_status_, - arg.create_scn_, - ls))) { + } else if (OB_BREAK_FAIL(inner_create_ls_(arg.ls_id_, + arg.migration_status_, + arg.restore_status_, + arg.create_scn_, + ls))) { LOG_WARN("create ls failed", K(ret), K(arg.ls_id_)); } else { state = ObLSCreateState::CREATE_STATE_INNER_CREATED; ObLSLockGuard lock_ls(ls); const ObLSMeta &ls_meta = ls->get_ls_meta(); - if (OB_FAIL(add_ls_to_map_(ls))) { + if (OB_BREAK_FAIL(add_ls_to_map_(ls))) { LOG_WARN("add log stream to map failed.", K(ret)); } else if (FALSE_IT(state = ObLSCreateState::CREATE_STATE_ADDED_TO_MAP)) { // do nothing - } else if (OB_FAIL(write_prepare_create_ls_slog_(ls_meta))) { + } else if (OB_BREAK_FAIL(write_prepare_create_ls_slog_(ls_meta))) { LOG_WARN("fail to write create log stream slog", K(ls_meta)); } else if (FALSE_IT(state = ObLSCreateState::CREATE_STATE_WRITE_PREPARE_SLOG)) { - } else if (OB_FAIL(ls->create_ls(arg.tenant_role_, - arg.palf_base_info_, - arg.replica_type_))) { + } else if (OB_BREAK_FAIL(ls->create_ls(arg.tenant_role_, + arg.palf_base_info_, + arg.replica_type_))) { LOG_WARN("enable ls palf failed", K(ret), K(ls_meta)); } else if (FALSE_IT(state = ObLSCreateState::CREATE_STATE_PALF_ENABLED)) { } else if (arg.need_create_inner_tablet_ && - OB_FAIL(ls->create_ls_inner_tablet(arg.compat_mode_, - arg.create_scn_))) { + OB_BREAK_FAIL(ls->create_ls_inner_tablet(arg.compat_mode_, + arg.create_scn_))) { LOG_WARN("create ls inner tablet failed", K(ret), K(ls_meta)); - } else if (OB_FAIL(write_commit_create_ls_slog_(ls->get_ls_id(), - arg.create_type_))) { + } else if (FALSE_IT(state = ObLSCreateState::CREATE_STATE_INNER_TABLET_CREATED)) { + } else if (OB_BREAK_FAIL(write_commit_create_ls_slog_(ls->get_ls_id(), + arg.create_type_))) { LOG_WARN("fail to write create log stream commit slog", K(ret), K(ls_meta)); - } else if (FALSE_IT(state = ObLSCreateState::CREATE_STATE_FINISH)) { - } else if (OB_FAIL(ls->finish_create_ls())) { + } else if (OB_BREAK_FAIL(ls->finish_create_ls())) { LOG_WARN("finish create ls failed", KR(ret)); - } else if (OB_FAIL(post_create_ls_(arg.create_type_, ls))) { + } else if (FALSE_IT(state = ObLSCreateState::CREATE_STATE_FINISH)) { + } else if (OB_BREAK_FAIL(post_create_ls_(arg.create_type_, ls))) { LOG_WARN("post create ls failed", K(ret), K(ls_meta)); } else if (ObLSCreateType::MIGRATE == arg.create_type_ && - OB_FAIL(ls->get_ls_migration_handler()->add_ls_migration_task(arg.task_id_, - mig_arg))) { + OB_BREAK_FAIL(ls->get_ls_migration_handler()->add_ls_migration_task(arg.task_id_, + mig_arg))) { LOG_WARN("failed to add ls migration task", K(ret), K(mig_arg)); } - if (OB_FAIL(ret)) { - do { - need_retry = false; - if (state >= ObLSCreateState::CREATE_STATE_WRITE_PREPARE_SLOG) { - if (OB_TMP_FAIL(ls->set_remove_state())) { - need_retry = true; - LOG_ERROR("fail to set ls remove state", K(tmp_ret), K(ls_meta)); - } else if (OB_TMP_FAIL(write_abort_create_ls_slog_(ls->get_ls_id()))) { - need_retry = true; - LOG_ERROR("fail to write create log stream abort slog", K(tmp_ret), K(ls_meta)); - } - } - } while (need_retry); - do { - need_retry = false; - // TODO: yanyuan.cxf every remove disable or stop function need be re-entrant - if (state >= ObLSCreateState::CREATE_STATE_PALF_ENABLED) { - if (OB_SUCCESS != (tmp_ret = ls->remove_ls())) { - need_retry = true; - LOG_WARN("ls disable palf failed", K(tmp_ret)); - } - } - } while (need_retry); - } } - if (OB_FAIL(ret)) { + if (OB_BREAK_FAIL(ret)) { del_ls_after_create_ls_failed_(state, ls); } } @@ -1191,22 +1141,73 @@ int ObLSService::create_ls_for_ha( return ret; } -void ObLSService::del_ls_after_create_ls_failed_(ObLSCreateState& ls_create_state, ObLS *ls) +void ObLSService::del_ls_after_create_ls_failed_(ObLSCreateState& in_ls_create_state, ObLS *ls) { + int ret = OB_SUCCESS; + int tmp_ret = OB_SUCCESS; + bool need_retry = false; + const bool remove_from_disk = true; + ObLSHandle handle; + ObLSCreateState ls_create_state = in_ls_create_state; if (OB_NOT_NULL(ls)) { - int tmp_ret = OB_SUCCESS; - bool need_retry = false; do { need_retry = false; - if (ls_create_state >= ObLSCreateState::CREATE_STATE_ADDED_TO_MAP) { - if (OB_SUCCESS != (tmp_ret = remove_ls_from_map_(ls->get_ls_id()))) { + tmp_ret = OB_SUCCESS; + if (ls_create_state >= ObLSCreateState::CREATE_STATE_FINISH) { + if (OB_TMP_FAIL(handle.set_ls(ls_map_, *ls, ObLSGetMod::TXSTORAGE_MOD))) { need_retry = true; - LOG_ERROR_RET(tmp_ret, "remove ls from map failed", K(tmp_ret)); + LOG_WARN("get ls handle failed", K(tmp_ret), KPC(ls)); + } else if (OB_TMP_FAIL(safe_remove_ls_(handle, remove_from_disk))) { + need_retry = true; + LOG_WARN("safe remove ls failed", K(tmp_ret)); } - } else if (ls_create_state >= ObLSCreateState::CREATE_STATE_INNER_CREATED) { - if (OB_SUCCESS != (tmp_ret = inner_del_ls_(ls))) { - need_retry = true; - LOG_ERROR_RET(tmp_ret, "inner del ls failed.", K(tmp_ret)); + } else { + if (ls_create_state >= ObLSCreateState::CREATE_STATE_INNER_TABLET_CREATED) { + if (OB_TMP_FAIL(ls->remove_ls_inner_tablet())) { + need_retry = true; + LOG_WARN("remove ls inner tablet failed", K(tmp_ret)); + } else { + ls_create_state = ObLSCreateState::CREATE_STATE_PALF_ENABLED; + } + } + if (OB_TMP_FAIL(tmp_ret)) { + } else if (ls_create_state >= ObLSCreateState::CREATE_STATE_PALF_ENABLED) { + if (OB_TMP_FAIL(ls->remove_ls())) { + need_retry = true; + LOG_WARN("ls inner remove failed", K(tmp_ret)); + } else { + ls_create_state = ObLSCreateState::CREATE_STATE_WRITE_PREPARE_SLOG; + } + } + if (OB_TMP_FAIL(tmp_ret)) { + } else if (ls_create_state >= ObLSCreateState::CREATE_STATE_WRITE_PREPARE_SLOG) { + if (OB_TMP_FAIL(ls->set_remove_state())) { + need_retry = true; + LOG_ERROR("fail to set ls remove state", K(tmp_ret), KPC(ls)); + } else if (OB_TMP_FAIL(write_abort_create_ls_slog_(ls->get_ls_id()))) { + need_retry = true; + LOG_ERROR("fail to write create log stream abort slog", K(tmp_ret), KPC(ls)); + } else { + ls_create_state = ObLSCreateState::CREATE_STATE_ADDED_TO_MAP; + } + } + if (OB_TMP_FAIL(tmp_ret)) { + } else if (ls_create_state >= ObLSCreateState::CREATE_STATE_ADDED_TO_MAP) { + if (OB_TMP_FAIL(remove_ls_from_map_(ls->get_ls_id()))) { + need_retry = true; + LOG_ERROR_RET(tmp_ret, "remove ls from map failed", K(tmp_ret)); + } else { + ls_create_state = ObLSCreateState::CREATE_STATE_INIT; + } + } + if (OB_TMP_FAIL(tmp_ret)) { + } else if (ls_create_state >= ObLSCreateState::CREATE_STATE_INNER_CREATED) { + if (OB_TMP_FAIL(inner_del_ls_(ls))) { + need_retry = true; + LOG_ERROR_RET(tmp_ret, "inner del ls failed.", K(tmp_ret)); + } else { + ls_create_state = ObLSCreateState::CREATE_STATE_INIT; + } } } } while (need_retry); diff --git a/src/storage/tx_storage/ob_ls_service.h b/src/storage/tx_storage/ob_ls_service.h index eb25d8dd5..5be1ccf81 100644 --- a/src/storage/tx_storage/ob_ls_service.h +++ b/src/storage/tx_storage/ob_ls_service.h @@ -49,6 +49,8 @@ class ObLSService static const int64_t DEFAULT_LOCK_TIMEOUT = 60_s; static const int64_t SMALL_TENANT_MEMORY_LIMIT = 4 * 1024 * 1024 * 1024L; // 4G static const int64_t TENANT_MEMORY_PER_LS_NEED = 200 * 1024 * 1024L; // 200MB +public: + int64_t break_point = -1; // just for test public: ObLSService(); ~ObLSService(); @@ -71,7 +73,7 @@ public: int create_ls(const obrpc::ObCreateLSArg &arg); // delete a LS // @param [in] ls_id, which LS is to be removed. - int remove_ls(const share::ObLSID &ls_id, const bool is_replay); + int remove_ls(const share::ObLSID &ls_id); // create a LS for HighAvaiable // @param [in] meta_package, all the parameters that is needed to create a LS for ha int create_ls_for_ha(const share::ObTaskId task_id, const ObMigrationOpArg &arg); @@ -155,6 +157,7 @@ private: CREATE_STATE_ADDED_TO_MAP = 2, // add_ls_to_map_ succ CREATE_STATE_WRITE_PREPARE_SLOG = 3, // write_prepare_create_ls_slog_ succ CREATE_STATE_PALF_ENABLED = 4, // enable_palf succ + CREATE_STATE_INNER_TABLET_CREATED = 5, // have created inner tablet CREATE_STATE_FINISH }; struct ObCreateLSCommonArg { @@ -190,6 +193,7 @@ private: int write_remove_ls_slog_(const share::ObLSID &ls_id) const; int remove_ls_from_map_(const share::ObLSID &ls_id); void remove_ls_(ObLS *ls, const bool remove_from_disk = true); + int safe_remove_ls_(ObLSHandle handle, const bool remove_from_disk); int replay_update_ls_(const ObLSMeta &ls_meta); int restore_update_ls_(const ObLSMetaPackage &meta_package); int replay_remove_ls_(const share::ObLSID &ls_id); diff --git a/src/storage/tx_storage/ob_tenant_freezer.cpp b/src/storage/tx_storage/ob_tenant_freezer.cpp index 20472f0a6..2f23472c9 100644 --- a/src/storage/tx_storage/ob_tenant_freezer.cpp +++ b/src/storage/tx_storage/ob_tenant_freezer.cpp @@ -1059,6 +1059,7 @@ int ObTenantFreezer::get_tenant_mem_stat_(ObTenantStatistic &stat) stat.tenant_memory_limit_ = get_tenant_memory_limit(tenant_id); stat.tenant_memory_hold_ = get_tenant_memory_hold(tenant_id); stat.max_cached_memstore_size_ = max_cached_memstore_size; + stat.memstore_can_get_now_ = ctx.max_mem_memstore_can_get_now_; stat.memstore_allocated_pos_ = memstore_allocated_pos; stat.memstore_frozen_pos_ = memstore_frozen_pos; diff --git a/src/storage/tx_table/ob_tx_table.cpp b/src/storage/tx_table/ob_tx_table.cpp index 1c19404bc..7cb74b6fc 100644 --- a/src/storage/tx_table/ob_tx_table.cpp +++ b/src/storage/tx_table/ob_tx_table.cpp @@ -451,9 +451,13 @@ int ObTxTable::remove_tablet() if (OB_NOT_NULL(ls_)) { if (OB_FAIL(remove_tablet_(LS_TX_DATA_TABLET))) { LOG_WARN("remove tx data tablet failed", K(ret)); + ob_usleep(1000 * 1000); + ob_abort(); } if (OB_FAIL(remove_tablet_(LS_TX_CTX_TABLET))) { LOG_WARN("remove tx ctx tablet failed", K(ret)); + ob_usleep(1000 * 1000); + ob_abort(); } } return ret; diff --git a/unittest/storage/blocksstable/ob_multi_version_sstable_test.h b/unittest/storage/blocksstable/ob_multi_version_sstable_test.h index 9be389c52..aa4af5df8 100644 --- a/unittest/storage/blocksstable/ob_multi_version_sstable_test.h +++ b/unittest/storage/blocksstable/ob_multi_version_sstable_test.h @@ -248,7 +248,7 @@ void ObMultiVersionSSTableTest::SetUpTestCase() void ObMultiVersionSSTableTest::TearDownTestCase() { - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ObLSID(ls_id_), false)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ObLSID(ls_id_))); ObKVGlobalCache::get_instance().destroy(); //ObIODeviceWrapper::get_instance().destroy(); OB_STORE_CACHE.destroy(); diff --git a/unittest/storage/test_compaction_policy.cpp b/unittest/storage/test_compaction_policy.cpp index b35857c13..f9c21ad5f 100644 --- a/unittest/storage/test_compaction_policy.cpp +++ b/unittest/storage/test_compaction_policy.cpp @@ -225,7 +225,7 @@ void TestCompactionPolicy::SetUpTestCase() void TestCompactionPolicy::TearDownTestCase() { int ret = OB_SUCCESS; - ret = MTL(ObLSService*)->remove_ls(ObLSID(TEST_LS_ID), false); + ret = MTL(ObLSService*)->remove_ls(ObLSID(TEST_LS_ID)); ASSERT_EQ(OB_SUCCESS, ret); ObTenantMetaMemMgr *t3m = MTL(ObTenantMetaMemMgr*); ASSERT_EQ(OB_SUCCESS, ret); diff --git a/unittest/storage/test_protected_memtable_mgr_handle.cpp b/unittest/storage/test_protected_memtable_mgr_handle.cpp index 414cf7df0..1a5692996 100644 --- a/unittest/storage/test_protected_memtable_mgr_handle.cpp +++ b/unittest/storage/test_protected_memtable_mgr_handle.cpp @@ -99,7 +99,7 @@ TEST_F(TestTabletMemtableMgr, tablet_memtable_mgr) { ASSERT_EQ(OB_ENTRY_NOT_EXIST, protected_handle->get_active_memtable(handle)); ASSERT_EQ(0, pool->count_); - ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id, false)); + ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id)); } diff --git a/unittest/storage/tx_storage/test_create_tablet_clog.cpp b/unittest/storage/tx_storage/test_create_tablet_clog.cpp index 8d1a02baa..0d9e1f3cb 100644 --- a/unittest/storage/tx_storage/test_create_tablet_clog.cpp +++ b/unittest/storage/tx_storage/test_create_tablet_clog.cpp @@ -130,7 +130,7 @@ TEST_F(TestCreateTabletClog, replay_create_tablet_clog_test) // 4. remove tablet ASSERT_EQ(OB_SUCCESS, ls_service->delete_tablet(ls_id, tablet_id)); - EXPECT_EQ(OB_SUCCESS, ls_service->remove_ls(ls_id, true)); + EXPECT_EQ(OB_SUCCESS, ls_service->remove_ls(ls_id)); if (buffer != nullptr) { ob_free(buffer);