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

mittest/simple_server/test_observer_expand_shrink.cpp

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

src/observer/omt/ob_multi_tenant.cpp

@@ -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,
+int ObMultiTenant::update_tenant_unit_no_lock(const ObUnitInfoGetter::ObTenantConfig &unit)
-                                              const UpdateTenantConfigOpt &opt)
 {
   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 int64_t expected_log_disk_size)
-                                               const UpdateTenantConfigOpt &opt)
 {
   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 (OB_FAIL(log_service->get_palf_disk_usage(unused_log_disk_size, old_log_disk_size))) {
-    } 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))) {
       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 (OB_FAIL(log_service->update_log_disk_usage_limit_size(expected_log_disk_size))) {
-        if (opt == UpdateTenantConfigOpt::NORMAL_UPDATE_TENANT_CONFIG_OPT) {
+        LOG_WARN("failed to update_log_disk_usage_limit_size", K(ret), K(tenant_id),
-         if (OB_FAIL(log_service->update_log_disk_usage_limit_size(expected_log_disk_size))) {
+               K(expected_log_disk_size));
-          LOG_WARN("failed to update_log_disk_usage_limit_size", K(ret), K(tenant_id),
+      } else {
-                 K(expected_log_disk_size));
+        LOG_INFO("update_tenant_log_disk_size success", K(ret), K(tenant_id),
-        } else {
+               K(expected_log_disk_size));
-          LOG_INFO("update_tenant_log_disk_size success", K(ret), K(tenant_id), K(opt),
-                 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);

src/observer/omt/ob_multi_tenant.h

@@ -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 int64_t expected_log_disk_size);
-                                  const UpdateTenantConfigOpt &opt);
   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,
+  int update_tenant_unit_no_lock(const share::ObUnitInfoGetter::ObTenantConfig &unit);
-                                 const UpdateTenantConfigOpt &opt);
 
 protected:
       static const int DEL_TRY_TIMES = 30;
-  enum class ObTenantCreateStep {
+      enum class ObTenantCreateStep {
-      STEP_BEGIN = 0, // begin
+        STEP_BEGIN = 0, // begin
-      STEP_CTX_MEM_CONFIG_SETTED = 1, // set_tenant_ctx_idle succ
+        STEP_CTX_MEM_CONFIG_SETTED = 1, // set_tenant_ctx_idle succ
-      STEP_LOG_DISK_SIZE_PINNED = 2,  // pin log disk size succ
+        STEP_LOG_DISK_SIZE_PINNED = 2,  // pin log disk size succ
-      STEP_TENANT_NEWED = 3, // new tenant succ
+        STEP_TENANT_NEWED = 3, // new tenant succ
-      STEP_WRITE_PREPARE_SLOG = 4, // write_prepare_create_tenant_slog succ
+        STEP_WRITE_PREPARE_SLOG = 4, // write_prepare_create_tenant_slog succ
-      STEP_FINISH,
+        STEP_FINISH,
-  };
+      };
 
   bool is_inited_;
   storage::ObStorageLogger *server_slogger_;

src/observer/omt/ob_tenant.cpp

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

src/observer/omt/ob_tenant_meta.h

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

unittest/logservice/test_server_log_block_mgr.cpp

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