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

revert(logservice): hidden sys tenant will actually occupy the log disk space.

Browse Source
This commit is contained in:
HaHaJeff
2023-05-07 03:42:24 +00:00
committed by ob-robot
parent 70fa0179cd
commit 0f30c4a321
6 changed files with 100 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
mittest/simple_server/test_observer_expand_shrink.cpp
View File

@ -102,6 +102,18 @@ TEST_F(ObserverExpandShink, basic_func)
log_disk_percentage));
}
//class ObserverExpandShinkRestart: public ObSimpleClusterTestBase
//{
//public:
// ObserverExpandShinkRestart() : ObSimpleClusterTestBase(TEST_FILE_NAME) {}
//};
//
//TEST_F(ObserverExpandShinkRestart, create_tenant_after_restart)
//{
// EXPECT_NE(0, GCTX.log_block_mgr_->min_log_disk_size_for_all_tenants_);
// SERVER_LOG(INFO, "create_tenant_after_restart trace", KPC(GCTX.log_block_mgr_));
//}
TEST_F(ObserverExpandShink, direct_set_observer)
{
GCONF.log_disk_size = 1024 * 1024 * 1024ul * 3;
@ -141,8 +153,63 @@ TEST_F(ObserverExpandShink, direct_set_observer)
}
}
TEST_F(ObserverExpandShink, test_hidden_sys_tenant)
{
omt::ObMultiTenant *omt = GCTX.omt_;
bool remove_tenant_succ = false;
int64_t log_disk_size_in_use = GCTX.log_block_mgr_->min_log_disk_size_for_all_tenants_;
EXPECT_EQ(log_disk_size_in_use, GCTX.log_block_mgr_->min_log_disk_size_for_all_tenants_);
share::TenantUnits units;
EXPECT_EQ(OB_SUCCESS, omt->get_tenant_units(units));
EXPECT_EQ(false, units.empty());
bool has_sys_tenant = false;
int64_t origin_sys_log_disk_size = 0;
int64_t hidden_sys_log_disk_size = 0;
for (int i = 0; i < units.count(); i++) {
if (OB_SYS_TENANT_ID == units[i].tenant_id_) {
origin_sys_log_disk_size = units[i].config_.log_disk_size();
EXPECT_EQ(OB_SUCCESS, omt->convert_real_to_hidden_sys_tenant());
}
}
EXPECT_EQ(OB_SUCCESS, omt->get_tenant_units(units));
EXPECT_EQ(false, units.empty());
ObUnitInfoGetter::ObTenantConfig sys_unit_config;
for (int i = 0; i < units.count(); i++) {
if (OB_SYS_TENANT_ID == units[i].tenant_id_) {
hidden_sys_log_disk_size = units[i].config_.log_disk_size();
sys_unit_config = units[i];
sys_unit_config.config_.resource_.log_disk_size_ = origin_sys_log_disk_size + 512*1024*1024;
}
}
CLOG_LOG(INFO, "runlin trace convert_hidden_to_real_sys_tenant", K(log_disk_size_in_use), KPC(GCTX.log_block_mgr_), K(origin_sys_log_disk_size), K(hidden_sys_log_disk_size));
// 类型转换后，sys租户的unit规格可能会发生变化（隐藏sys租户的规格会被重新生成，具体逻辑参见gen_sys_tenant_unit_config）
EXPECT_EQ(log_disk_size_in_use-origin_sys_log_disk_size+hidden_sys_log_disk_size,
GCTX.log_block_mgr_->min_log_disk_size_for_all_tenants_);
log_disk_size_in_use = GCTX.log_block_mgr_->min_log_disk_size_for_all_tenants_;
EXPECT_EQ(OB_SUCCESS, omt->convert_hidden_to_real_sys_tenant(sys_unit_config));
has_sys_tenant = true;
EXPECT_EQ(log_disk_size_in_use-hidden_sys_log_disk_size+sys_unit_config.config_.log_disk_size(),
GCTX.log_block_mgr_->min_log_disk_size_for_all_tenants_);
log_disk_size_in_use = GCTX.log_block_mgr_->min_log_disk_size_for_all_tenants_;
CLOG_LOG(INFO, "runlin trace after convert_hidden_to_real_sys_tenant", K(log_disk_size_in_use), KPC(GCTX.log_block_mgr_),
K(origin_sys_log_disk_size));
int64_t new_sys_log_disk_size = 2 *1024*1024*1024l +512*1024*1024;
EXPECT_EQ(OB_SUCCESS, omt->update_tenant_log_disk_size(OB_SYS_TENANT_ID, new_sys_log_disk_size));
EXPECT_EQ(true, has_sys_tenant);
EXPECT_EQ(log_disk_size_in_use-sys_unit_config.config_.log_disk_size()+new_sys_log_disk_size,
GCTX.log_block_mgr_->min_log_disk_size_for_all_tenants_);
CLOG_LOG(INFO, "runlin trace after convert_real_to_hidden_sys_tenant", K(log_disk_size_in_use), KPC(GCTX.log_block_mgr_),
K(origin_sys_log_disk_size));
}
TEST_F(ObserverExpandShink, paralle_set)
{
omt::ObTenantNodeBalancer::get_instance().refresh_interval_ = 1000 * 1000 * 1000;
sleep(3);
LOG_INFO("start to test parallel_set");
share::ObTenantSwitchGuard tguard;
ASSERT_EQ(OB_SUCCESS, tguard.switch_to(1));
@ -180,23 +247,6 @@ TEST_F(ObserverExpandShink, paralle_set)
}
}
class ObserverExpandShinkRestart: public ObSimpleClusterTestBase
{
public:
ObserverExpandShinkRestart() : ObSimpleClusterTestBase(TEST_FILE_NAME) {}
};
TEST_F(ObserverExpandShinkRestart, observer_start)
{
SERVER_LOG(INFO, "restart observer success");
}
TEST_F(ObserverExpandShinkRestart, create_tenant_after_restart)
{
EXPECT_NE(0, GCTX.log_block_mgr_->min_log_disk_size_for_all_tenants_);
SERVER_LOG(INFO, "create_tenant_after_restart trace", KPC(GCTX.log_block_mgr_));
}
} // end unittest
} // end oceanbase

57
src/observer/omt/ob_multi_tenant.cpp
View File

@ -611,8 +611,6 @@ int ObMultiTenant::create_hidden_sys_tenant()
LOG_ERROR("fail to construct meta", K(ret));
} else if (OB_FAIL(create_tenant(meta, true/* write_slog*/))) {
LOG_ERROR("create hidden sys tenant failed", K(ret));
} else {
LOG_INFO("create hidden sys tenant success", K(ret), K(meta));
}
return ret;
@ -713,7 +711,7 @@ int ObMultiTenant::convert_hidden_to_real_sys_tenant(const ObUnitInfoGetter::ObT
LOG_WARN("must be hidden sys tenant", K(ret));
} else if (FALSE_IT(new_super_block = tenant->get_super_block())) {
} else if (FALSE_IT(new_super_block.is_hidden_ = false)) {
} else if (OB_FAIL(update_tenant_unit_no_lock(unit, UpdateTenantConfigOpt::CONVERT_HIDDEN_TO_REAL_SYS_TENANT))) {
} else if (OB_FAIL(update_tenant_unit_no_lock(unit))) {
LOG_WARN("fail to update_tenant_unit_no_lock", K(ret), K(unit));
} else if (OB_FAIL(ObServerCheckpointSlogHandler::get_instance()
.write_tenant_super_block_slog(new_super_block))) {
@ -747,7 +745,6 @@ int ObMultiTenant::create_tenant(const ObTenantMeta &meta, bool write_slog, cons
int64_t bucket_lock_idx = -1;
const int64_t log_disk_size = meta.unit_.config_.log_disk_size();
int64_t lock_timeout_ts = abs_timeout_us - 5000000; // reserve 5s for creating tenant
bool is_hidden_sys = meta.is_hidden();
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
@ -801,17 +798,15 @@ int ObMultiTenant::create_tenant(const ObTenantMeta &meta, bool write_slog, cons
create_step = ObTenantCreateStep::STEP_CTX_MEM_CONFIG_SETTED; // step1
}
}
if (OB_SUCC(ret)) {
if (!is_virtual_tenant_id(tenant_id)
&& !is_hidden_sys
&& OB_FAIL(GCTX.log_block_mgr_->create_tenant(log_disk_size))) {
LOG_ERROR("create_tenant in ObServerLogBlockMgr failed", KR(ret));
}
// if create_tenant in ObServerLogBlockMGR success, the log disk size need by this tenant has been pinned,
// otherwise, the assigned log disk size of ObServerLogBlockMGR is origin.
if (OB_SUCC(ret)) {
create_step = ObTenantCreateStep::STEP_LOG_DISK_SIZE_PINNED;
create_step = ObTenantCreateStep::STEP_LOG_DISK_SIZE_PINNED; // step2
}
}
@ -825,6 +820,7 @@ int ObMultiTenant::create_tenant(const ObTenantMeta &meta, bool write_slog, cons
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("new tenant fail", K(ret));
} else if (FALSE_IT(create_step = ObTenantCreateStep::STEP_TENANT_NEWED)) { //step3
} else if (OB_FAIL(tenant->init_ctx())) {
LOG_WARN("init ctx fail", K(tenant_id), K(ret));
} else if (write_slog) {
@ -924,7 +920,7 @@ int ObMultiTenant::create_tenant(const ObTenantMeta &meta, bool write_slog, cons
do {
tmp_ret = OB_SUCCESS;
if (create_step >= ObTenantCreateStep::STEP_LOG_DISK_SIZE_PINNED) {
if (!is_virtual_tenant_id(tenant_id) && !is_hidden_sys) {
if (!is_virtual_tenant_id(tenant_id)) {
GCTX.log_block_mgr_->abort_create_tenant(log_disk_size);
}
}
@ -948,8 +944,7 @@ int ObMultiTenant::create_tenant(const ObTenantMeta &meta, bool write_slog, cons
return ret;
}
int ObMultiTenant::update_tenant_unit_no_lock(const ObUnitInfoGetter::ObTenantConfig &unit,
const UpdateTenantConfigOpt &opt)
int ObMultiTenant::update_tenant_unit_no_lock(const ObUnitInfoGetter::ObTenantConfig &unit)
{
int ret = OB_SUCCESS;
@ -958,9 +953,6 @@ int ObMultiTenant::update_tenant_unit_no_lock(const ObUnitInfoGetter::ObTenantCo
const double max_cpu = static_cast<double>(unit.config_.max_cpu());
const uint64_t tenant_id = unit.tenant_id_;
int64_t allowed_mem_limit = 0;
// when opt is UpdateTenantConfigOpt::CONVERT_REAL_TO_HIDDEN_SYS_TENANT, the new_log_disk_size should set to zero.
const int64_t new_log_disk_size =
opt == UpdateTenantConfigOpt::CONVERT_REAL_TO_HIDDEN_SYS_TENANT ? 0 : unit.config_.log_disk_size();
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
@ -978,7 +970,7 @@ int ObMultiTenant::update_tenant_unit_no_lock(const ObUnitInfoGetter::ObTenantCo
LOG_WARN("fail to update_tenant_freezer_mem_limit", K(ret), K(tenant_id));
} else if (OB_FAIL(tenant->update_thread_cnt(max_cpu))) {
LOG_WARN("fail to update mtl module thread_cnt", K(ret), K(tenant_id));
} else if (OB_FAIL(update_tenant_log_disk_size(tenant_id, new_log_disk_size, opt))) {
} else if (OB_FAIL(update_tenant_log_disk_size(tenant_id, unit.config_.log_disk_size()))) {
LOG_WARN("fail to update tenant log disk size", K(ret), K(tenant_id));
} else if (FALSE_IT(tenant->update_memory_size(unit.config_.memory_size()))) {
// unreachable
@ -1009,7 +1001,7 @@ int ObMultiTenant::update_tenant_unit(const ObUnitInfoGetter::ObTenantConfig &un
} else if (OB_FAIL(bucket_lock_.wrlock(bucket_lock_idx = get_tenant_lock_bucket_idx(tenant_id)))) {
LOG_WARN("fail to try_wrlock for update tenant unit", K(ret), K(tenant_id), K(bucket_lock_idx));
} else if (FALSE_IT(lock_succ = true)) {
} else if (OB_FAIL(update_tenant_unit_no_lock(unit, UpdateTenantConfigOpt::NORMAL_UPDATE_TENANT_CONFIG_OPT))) {
} else if (OB_FAIL(update_tenant_unit_no_lock(unit))) {
LOG_WARN("fail to update_tenant_unit_no_lock", K(ret), K(unit));
}
@ -1059,8 +1051,7 @@ int ObMultiTenant::update_tenant_memory(const uint64_t tenant_id, const int64_t
}
int ObMultiTenant::update_tenant_log_disk_size(const uint64_t tenant_id,
const int64_t expected_log_disk_size,
const UpdateTenantConfigOpt &opt)
const int64_t expected_log_disk_size)
{
int ret = OB_SUCCESS;
MAKE_TENANT_SWITCH_SCOPE_GUARD(guard);
@ -1070,26 +1061,20 @@ int ObMultiTenant::update_tenant_log_disk_size(const uint64_t tenant_id,
ObLogService *log_service = MTL(ObLogService *);
if (OB_ISNULL(log_service)) {
ret = OB_ERR_UNEXPECTED;
// when opt is UpdateTenantConfigOpt::CONVERT_HIDDEN_TO_REAL_SYS_TENANT, the old_log_disk_size is zero.
} else if (opt != UpdateTenantConfigOpt::CONVERT_HIDDEN_TO_REAL_SYS_TENANT
&& OB_FAIL(log_service->get_palf_disk_usage(unused_log_disk_size, old_log_disk_size))) {
} else if (OB_FAIL(log_service->get_palf_disk_usage(unused_log_disk_size, old_log_disk_size))) {
LOG_WARN("failed to get_palf_disk_usage", K(ret), K(unused_log_disk_size), K(old_log_disk_size),
K(expected_log_disk_size));
} else if(OB_FAIL(GCTX.log_block_mgr_->update_tenant(old_log_disk_size, expected_log_disk_size))) {
LOG_WARN("failed to update_tenant in ObServerLogBlockMgr", K(ret), K(old_log_disk_size),
K(expected_log_disk_size));
} else {
// Only when opt is UpdateTenantConfigOpt::NORMAL_UPDATE_TENANT_CONFIG_OPT update palf.
if (opt == UpdateTenantConfigOpt::NORMAL_UPDATE_TENANT_CONFIG_OPT) {
if (OB_FAIL(log_service->update_log_disk_usage_limit_size(expected_log_disk_size))) {
LOG_WARN("failed to update_log_disk_usage_limit_size", K(ret), K(tenant_id),
K(expected_log_disk_size));
} else {
LOG_INFO("update_tenant_log_disk_size success", K(ret), K(tenant_id), K(opt),
K(expected_log_disk_size));
}
if (OB_FAIL(log_service->update_log_disk_usage_limit_size(expected_log_disk_size))) {
LOG_WARN("failed to update_log_disk_usage_limit_size", K(ret), K(tenant_id),
K(expected_log_disk_size));
} else {
LOG_INFO("update_tenant_log_disk_size success", K(ret), K(tenant_id),
K(expected_log_disk_size));
}
if (false == is_virtual_tenant_id(tenant_id) && OB_FAIL(ret)) {
GCTX.log_block_mgr_->abort_update_tenant(expected_log_disk_size, old_log_disk_size);
}
@ -1471,11 +1456,6 @@ int ObMultiTenant::remove_tenant(const uint64_t tenant_id, bool &remove_tenant_s
KP(removed_tenant), K(removed_tenant->lock_));
removed_tenant->lock_.ld_.print();
} else {
const share::ObUnitInfoGetter::ObTenantConfig &config = removed_tenant->get_unit();
const int64_t log_disk_size = config.config_.log_disk_size();
if (!removed_tenant->is_hidden() && !is_virtual_tenant_id(tenant_id)) {
GCTX.log_block_mgr_->remove_tenant(log_disk_size);
}
ObTenant *removed_tenant_tmp = nullptr;
SpinWLockGuard guard(lock_);
// This locking should be held after tenant->wait
@ -1492,6 +1472,11 @@ int ObMultiTenant::remove_tenant(const uint64_t tenant_id, bool &remove_tenant_s
}
if (OB_SUCC(ret)) {
const share::ObUnitInfoGetter::ObTenantConfig &config = removed_tenant->get_unit();
const int64_t log_disk_size = config.config_.log_disk_size();
if (!is_virtual_tenant_id(tenant_id)) {
GCTX.log_block_mgr_->remove_tenant(log_disk_size);
}
removed_tenant->destroy();
ob_delete(removed_tenant);
LOG_INFO("remove tenant success", K(tenant_id));
@ -1691,7 +1676,7 @@ int ObMultiTenant::convert_real_to_hidden_sys_tenant()
} else if (OB_FAIL(bucket_lock_.try_wrlock(bucket_lock_idx = get_tenant_lock_bucket_idx(tenant_id)))) {
LOG_WARN("fail to try_wrlock for delete tenant", K(ret), K(tenant_id), K(bucket_lock_idx));
} else if (FALSE_IT(lock_succ = true)) {
} else if (OB_FAIL(update_tenant_unit_no_lock(tenant_meta.unit_, UpdateTenantConfigOpt::CONVERT_REAL_TO_HIDDEN_SYS_TENANT))) {
} else if (OB_FAIL(update_tenant_unit_no_lock(tenant_meta.unit_))) {
LOG_WARN("fail to update_tenant_unit_no_lock", K(ret), K(tenant_meta));
} else {
ObTenantSwitchGuard guard(tenant);

28
src/observer/omt/ob_multi_tenant.h
View File

@ -73,12 +73,6 @@ typedef common::ObSortedVector<ObTenant*> TenantList;
typedef TenantList::iterator TenantIterator;
typedef common::ObVector<uint64_t> TenantIdList;
enum class UpdateTenantConfigOpt {
CONVERT_HIDDEN_TO_REAL_SYS_TENANT = 0,
CONVERT_REAL_TO_HIDDEN_SYS_TENANT = 1,
NORMAL_UPDATE_TENANT_CONFIG_OPT = 2
};
// This is the entry class of OMT module.
class ObMultiTenant
: public share::ObThreadPool
@ -116,8 +110,7 @@ public:
int update_tenant_cpu(const uint64_t tenant_id, const double min_cpu, const double max_cpu);
int update_tenant_memory(const uint64_t tenant_id, const int64_t mem_limit, int64_t &allowed_mem_limit);
int update_tenant_log_disk_size(const uint64_t tenant_id,
const int64_t expected_log_disk_size,
const UpdateTenantConfigOpt &opt);
const int64_t expected_log_disk_size);
int modify_tenant_io(const uint64_t tenant_id, const share::ObUnitConfig &unit_config);
int update_tenant_config(uint64_t tenant_id);
int update_palf_config();
@ -182,19 +175,18 @@ protected:
int create_virtual_tenants();
int remove_tenant(const uint64_t tenant_id, bool &remove_tenant_succ);
uint32_t get_tenant_lock_bucket_idx(const uint64_t tenant_id);
int update_tenant_unit_no_lock(const share::ObUnitInfoGetter::ObTenantConfig &unit,
const UpdateTenantConfigOpt &opt);
int update_tenant_unit_no_lock(const share::ObUnitInfoGetter::ObTenantConfig &unit);
protected:
static const int DEL_TRY_TIMES = 30;
enum class ObTenantCreateStep {
STEP_BEGIN = 0, // begin
STEP_CTX_MEM_CONFIG_SETTED = 1, // set_tenant_ctx_idle succ
STEP_LOG_DISK_SIZE_PINNED = 2, // pin log disk size succ
STEP_TENANT_NEWED = 3, // new tenant succ
STEP_WRITE_PREPARE_SLOG = 4, // write_prepare_create_tenant_slog succ
STEP_FINISH,
};
enum class ObTenantCreateStep {
STEP_BEGIN = 0, // begin
STEP_CTX_MEM_CONFIG_SETTED = 1, // set_tenant_ctx_idle succ
STEP_LOG_DISK_SIZE_PINNED = 2, // pin log disk size succ
STEP_TENANT_NEWED = 3, // new tenant succ
STEP_WRITE_PREPARE_SLOG = 4, // write_prepare_create_tenant_slog succ
STEP_FINISH,
};
bool is_inited_;
storage::ObStorageLogger *server_slogger_;

2
src/observer/omt/ob_tenant.cpp
View File

@ -709,7 +709,7 @@ int ObTenant::construct_mtl_init_ctx(const ObTenantMeta &meta, share::ObTenantMo
bool ObTenant::is_hidden()
{
TCRLockGuard guard(meta_lock_);
return tenant_meta_.is_hidden();
return tenant_meta_.super_block_.is_hidden_;
}
ObTenantCreateStatus ObTenant::get_create_status()

5
src/observer/omt/ob_tenant_meta.h
View File

@ -51,11 +51,6 @@ public:
int build(const share::ObUnitInfoGetter::ObTenantConfig &unit,
const storage::ObTenantSuperBlock &super_block);
bool is_hidden() const
{
return super_block_.is_hidden_;
}
TO_STRING_KV(K_(unit), K_(super_block), K_(create_status));

3
unittest/logservice/test_server_log_block_mgr.cpp
View File

@ -130,7 +130,6 @@ public:
if (OB_SUCC(ret)) {
map_[key] = size;
} else {
//this->log_block_mgr_.abort_create_tenant(size);
}
}
return ret;
@ -141,7 +140,7 @@ public:
if (map_.end() == map_.find(key)) {
ret = OB_ENTRY_NOT_EXIST;
} else {
int64 size = map_[key];
int64_t size = map_[key];
map_.erase(key);
this->log_block_mgr_.remove_tenant(size);
}