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

BUGFIX: make sure clean the ls if created failed

Browse Source
This commit is contained in:
obdev 2024-02-08 06:25:33 +00:00 committed by ob-robot
parent 9c7c47feee
commit 6953548b56
36 changed files with 547 additions and 477 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h
View File

@ -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();

4
mittest/mtlenv/storage/checkpoint/test_checkpoint_executor.cpp
View File

@ -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));
}
}

4
mittest/mtlenv/storage/checkpoint/test_data_checkpoint.cpp
View File

@ -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));
}
}

2
mittest/mtlenv/storage/checkpoint/test_lock_memtable_checkpoint.cpp
View File

@ -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

2
mittest/mtlenv/storage/test_lob_manager.cpp
View File

@ -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)

2
mittest/mtlenv/storage/test_ls_migration_param.cpp
View File

@ -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();

2
mittest/mtlenv/storage/test_ls_restore_task_mgr.cpp
View File

@ -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");
}

69
mittest/mtlenv/storage/test_ls_service.cpp
View File

@ -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

2
mittest/mtlenv/storage/test_ls_tablet_info_writer_and_reader.cpp
View File

@ -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();

2
mittest/mtlenv/storage/test_ls_tablet_service.cpp
View File

@ -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();

2
mittest/mtlenv/storage/test_medium_info_reader.cpp
View File

@ -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;
}

2
mittest/mtlenv/storage/test_memtable_v2.cpp
View File

@ -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");

2
mittest/mtlenv/storage/test_table_scan_pure_data_table.cpp
View File

@ -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

2
mittest/mtlenv/storage/test_tablet_create_delete_helper.cpp
View File

@ -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();

2
mittest/mtlenv/storage/test_tablet_member_load_and_free.cpp
View File

@ -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;
}

2
mittest/mtlenv/storage/test_tablet_status.cpp
View File

@ -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();

2
mittest/mtlenv/storage/test_tablet_status_cache.cpp
View File

@ -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;
}

2
mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp
View File

@ -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();
}

6
mittest/mtlenv/storage/test_trans.cpp
View File

@ -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));
}

2
mittest/mtlenv/storage/test_write_tablet_slog.cpp
View File

@ -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();

6
mittest/mtlenv/tablelock/test_table_lock_flush.cpp
View File

@ -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

4
mittest/multi_replica/env/ob_simple_replica.cpp vendored
View File

@ -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});
}
};

4
mittest/simple_server/env/ob_simple_server.cpp vendored
View File

@ -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});
}
};

2
mittest/simple_server/test_tablet_autoinc_mgr.cpp
View File

@ -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

2
src/logservice/ob_garbage_collector.cpp
View File

@ -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));

563
src/storage/ls/ob_ls.cpp
View File

@ -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;

10
src/storage/ls/ob_ls.h
View File

@ -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,

6
src/storage/tablelock/ob_lock_table.cpp
View File

@ -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;
}

293
src/storage/tx_storage/ob_ls_service.cpp
View File

@ -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<ObLSIterator> 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);

6
src/storage/tx_storage/ob_ls_service.h
View File

@ -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);

1
src/storage/tx_storage/ob_tenant_freezer.cpp
View File

@ -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;

4
src/storage/tx_table/ob_tx_table.cpp
View File

@ -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;

2
unittest/storage/blocksstable/ob_multi_version_sstable_test.h
View File

@ -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();

2
unittest/storage/test_compaction_policy.cpp
View File

@ -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);

2
unittest/storage/test_protected_memtable_mgr_handle.cpp
View File

@ -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));
}

2
unittest/storage/tx_storage/test_create_tablet_clog.cpp
View File

@ -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);