oceanbase

1
/**
2
 * Copyright (c) 2021 OceanBase
3
 * OceanBase CE is licensed under Mulan PubL v2.
4
 * You can use this software according to the terms and conditions of the Mulan PubL v2.
5
 * You may obtain a copy of Mulan PubL v2 at:
6
 *          http://license.coscl.org.cn/MulanPubL-2.0
7
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
8
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
9
 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
10
 * See the Mulan PubL v2 for more details.
11
 */
12

13
#include "lib/ob_define.h"
14
#include "lib/ob_errno.h"
15
#include <cstdio>
16
#include <gtest/gtest.h>
17
#include <signal.h>
18
#include <stdexcept>
19
#define private public
20
#define protected public
21
#include "env/ob_simple_log_cluster_env.h"
22
#undef private
23
#undef protected
24
#include "logservice/palf/log_reader_utils.h"
25
#include "logservice/palf/log_define.h"
26
#include "logservice/palf/log_group_entry_header.h"
27
#include "logservice/palf/log_io_worker.h"
28
#include "logservice/palf/lsn.h"
29

30
const std::string TEST_NAME = "log_disk_mgr";
31

32
using namespace oceanbase::common;
33
using namespace oceanbase;
34
namespace oceanbase
35
{
36
using namespace logservice;
37
namespace unittest
38
{
39
class TestObSimpleLogDiskMgr : public ObSimpleLogClusterTestEnv
40
  {
41
  public:
42
    TestObSimpleLogDiskMgr() : ObSimpleLogClusterTestEnv()
43
    {
44
      int ret = init();
45
      if (OB_SUCCESS != ret) {
46
        throw std::runtime_error("TestObSimpleLogDiskMgr init failed");
47
      }
48
    }
49
    ~TestObSimpleLogDiskMgr()
50
    {
51
      destroy();
52
    }
53
    int init()
54
    {
55
      return OB_SUCCESS;
56
    }
57
    void destroy()
58
    {}
59
    int64_t id_;
60
  };
61

62
int64_t ObSimpleLogClusterTestBase::member_cnt_ = 1;
63
int64_t ObSimpleLogClusterTestBase::node_cnt_ = 1;
64
std::string ObSimpleLogClusterTestBase::test_name_ = TEST_NAME;
65
bool ObSimpleLogClusterTestBase::need_add_arb_server_  = false;
66

67
TEST_F(TestObSimpleLogDiskMgr, out_of_disk_space)
68
{
69
  update_server_log_disk(10*1024*1024*1024ul);
70
  update_disk_options(10*1024*1024*1024ul/palf::PALF_PHY_BLOCK_SIZE);
71
  SET_CASE_LOG_FILE(TEST_NAME, "out_of_disk_space");
72
  int64_t id = ATOMIC_AAF(&palf_id_, 1);
73
  int server_idx = 0;
74
  PalfEnv *palf_env = NULL;
75
  int64_t leader_idx = 0;
76
  PalfHandleImplGuard leader;
77
  share::SCN create_scn = share::SCN::base_scn();
78
  EXPECT_EQ(OB_SUCCESS, get_palf_env(server_idx, palf_env));
79
  EXPECT_EQ(OB_SUCCESS, create_paxos_group(id, create_scn, leader_idx, leader));
80
  update_disk_options(leader_idx, MIN_DISK_SIZE_PER_PALF_INSTANCE/PALF_PHY_BLOCK_SIZE + 2);
81
  EXPECT_EQ(OB_SUCCESS, submit_log(leader, 8*31+1, id, MAX_LOG_BODY_SIZE));
82
  LogStorage *log_storage = &leader.palf_handle_impl_->log_engine_.log_storage_;
83
  while (LSN(6*PALF_BLOCK_SIZE) > log_storage->log_tail_) {
84
    usleep(500);
85
  }
86
  EXPECT_EQ(OB_SUCCESS, submit_log(leader, 20, id, MAX_LOG_BODY_SIZE));
87
  while (LSN(6*PALF_BLOCK_SIZE + 20 * MAX_LOG_BODY_SIZE) > log_storage->log_tail_) {
88
    usleep(500);
89
  }
90
  LSN max_lsn = leader.palf_handle_impl_->get_max_lsn();
91
  wait_lsn_until_flushed(max_lsn, leader);
92
  PALF_LOG(INFO, "out of disk max_lsn", K(max_lsn));
93
  usleep(palf::BlockGCTimerTask::BLOCK_GC_TIMER_INTERVAL_MS + 5*10000);
94
  EXPECT_EQ(OB_LOG_OUTOF_DISK_SPACE, submit_log(leader, 1, id, MAX_LOG_BODY_SIZE));
95
  // shrinking 后继续停写
96
  update_disk_options(leader_idx, MIN_DISK_SIZE_PER_PALF_INSTANCE/PALF_PHY_BLOCK_SIZE);
97
  EXPECT_EQ(OB_LOG_OUTOF_DISK_SPACE, submit_log(leader, 1, id, MAX_LOG_BODY_SIZE));
98
  usleep(ObLooper::INTERVAL_US*2);
99
}
100

101
TEST_F(TestObSimpleLogDiskMgr, update_disk_options_basic)
102
{
103
  SET_CASE_LOG_FILE(TEST_NAME, "update_disk_options_basic");
104
  OB_LOGGER.set_log_level("INFO");
105
  const int64_t id = ATOMIC_AAF(&palf_id_, 1);
106
  // 将日志盘空间设置为10GB
107
  update_disk_options(10*1024*1024*1024ul/PALF_PHY_BLOCK_SIZE);
108
  PALF_LOG(INFO, "start update_disk_options_basic", K(id));
109
  int64_t leader_idx = 0;
110
  PalfHandleImplGuard leader;
111
  PalfEnv *palf_env = NULL;
112
  EXPECT_EQ(OB_SUCCESS, create_paxos_group(id, leader_idx, leader));
113
  EXPECT_EQ(OB_SUCCESS, get_palf_env(leader_idx, palf_env));
114

115
  // 提交1G的日志
116
  EXPECT_EQ(OB_SUCCESS, submit_log(leader, 500, id, MAX_LOG_BODY_SIZE));
117
  EXPECT_EQ(OB_SUCCESS, wait_lsn_until_flushed(leader.palf_handle_impl_->get_max_lsn(), leader));
118

119
  EXPECT_EQ(OB_SUCCESS, update_disk_options(leader_idx, 20));
120
  usleep(1000*1000+palf::BlockGCTimerTask::BLOCK_GC_TIMER_INTERVAL_MS);
121
  EXPECT_EQ(PalfDiskOptionsWrapper::Status::SHRINKING_STATUS,
122
            palf_env->palf_env_impl_.disk_options_wrapper_.status_);
123
  EXPECT_EQ(palf_env->palf_env_impl_.disk_options_wrapper_.disk_opts_for_recycling_blocks_.log_disk_usage_limit_size_,
124
            20*PALF_PHY_BLOCK_SIZE);
125

126
  // case1: 在上一次未缩容完成之前，可以继续缩容
127
  EXPECT_EQ(OB_SUCCESS, update_disk_options(leader_idx, 10));
128
  usleep(1000*1000+palf::BlockGCTimerTask::BLOCK_GC_TIMER_INTERVAL_MS);
129
  EXPECT_EQ(PalfDiskOptionsWrapper::Status::SHRINKING_STATUS,
130
            palf_env->palf_env_impl_.disk_options_wrapper_.status_);
131
  EXPECT_EQ(palf_env->palf_env_impl_.disk_options_wrapper_.disk_opts_for_recycling_blocks_.log_disk_usage_limit_size_,
132
            10*PALF_PHY_BLOCK_SIZE);
133
  // 此时日志盘依旧未完成缩容，ObSimpleLogServer维护的disk_opts_依旧是10GB
134
  {
135
    PalfDiskOptions opts;
136
    EXPECT_EQ(OB_SUCCESS, get_disk_options(leader_idx, opts));
137
    EXPECT_EQ(opts.log_disk_usage_limit_size_, 10*1024*1024*1024ul);
138
  }
139
  // case2: 在上一次未缩容完成之前，可以继续扩容, 同时由于扩容后日志盘依旧小于第一次缩容，因此依旧处于缩容状态.
140
  EXPECT_EQ(OB_SUCCESS, update_disk_options(leader_idx, 11));
141
  usleep(1000*1000+palf::BlockGCTimerTask::BLOCK_GC_TIMER_INTERVAL_MS);
142
  EXPECT_EQ(PalfDiskOptionsWrapper::Status::SHRINKING_STATUS,
143
            palf_env->palf_env_impl_.disk_options_wrapper_.status_);
144
  EXPECT_EQ(palf_env->palf_env_impl_.disk_options_wrapper_.disk_opts_for_recycling_blocks_.log_disk_usage_limit_size_,
145
            11*PALF_PHY_BLOCK_SIZE);
146
  // 此时日志盘依旧未完成缩容，ObSimpleLogServer维护的disk_opts_依旧是10GB
147
  {
148
    PalfDiskOptions opts;
149
    EXPECT_EQ(OB_SUCCESS, get_disk_options(leader_idx, opts));
150
    EXPECT_EQ(opts.log_disk_usage_limit_size_, 10*1024*1024*1024ul);
151
  }
152
  usleep(1000*1000+100+palf::BlockGCTimerTask::BLOCK_GC_TIMER_INTERVAL_MS);
153
  EXPECT_EQ(PalfDiskOptionsWrapper::Status::SHRINKING_STATUS,
154
            palf_env->palf_env_impl_.disk_options_wrapper_.status_);
155
  EXPECT_EQ(palf_env->palf_env_impl_.disk_options_wrapper_.disk_opts_for_recycling_blocks_.log_disk_usage_limit_size_,
156
            11*PALF_PHY_BLOCK_SIZE);
157
  EXPECT_EQ(OB_SUCCESS, wait_until_has_committed(leader, leader.palf_handle_impl_->get_max_lsn()));
158
  const LSN base_lsn(12*PALF_BLOCK_SIZE);
159
  EXPECT_EQ(OB_SUCCESS, leader.palf_handle_impl_->set_base_lsn(base_lsn));
160
  usleep(1000);
161
  EXPECT_EQ(OB_SUCCESS, submit_log(leader, 1, id, 1000));
162
  EXPECT_EQ(OB_SUCCESS, wait_lsn_until_flushed(leader.palf_handle_impl_->get_max_lsn(), leader));
163
  // wait until disk space enough
164
  EXPECT_EQ(OB_SUCCESS, wait_until_disk_space_to(leader_idx, (11*PALF_PHY_BLOCK_SIZE*80+100)/100));
165
  usleep(1000*1000+palf::BlockGCTimerTask::BLOCK_GC_TIMER_INTERVAL_MS);
166
  EXPECT_EQ(PalfDiskOptionsWrapper::Status::NORMAL_STATUS,
167
            palf_env->palf_env_impl_.disk_options_wrapper_.status_);
168
  EXPECT_EQ(palf_env->palf_env_impl_.disk_options_wrapper_.disk_opts_for_stopping_writing_.log_disk_usage_limit_size_,
169
            11*PALF_PHY_BLOCK_SIZE);
170
  // 等待后台线程再次执行update_disk_options操作，预期本地持久化的disk_opts会变为11*PALF_PHY_BLOCK_SIZE
171
  {
172
    usleep(2*ObLooper::INTERVAL_US);
173
    PalfDiskOptions opts;
174
    EXPECT_EQ(OB_SUCCESS, get_disk_options(leader_idx, opts));
175
    EXPECT_EQ(opts.log_disk_usage_limit_size_, 11*PALF_PHY_BLOCK_SIZE);
176
  }
177
}
178

179
TEST_F(TestObSimpleLogDiskMgr, shrink_log_disk)
180
{
181
  SET_CASE_LOG_FILE(TEST_NAME, "shrink_log_disk");
182
  OB_LOGGER.set_log_level("INFO");
183
  // 验证缩容由于单日志流最少需要512MB日志盘失败
184
  // 保证能同时容纳两个日志流
185
  PalfEnv *palf_env = NULL;
186
  int64_t leader_idx = 0;
187
  PalfHandleImplGuard leader;
188
  share::SCN create_scn = share::SCN::base_scn();
189
  int server_idx = 0;
190
  EXPECT_EQ(OB_SUCCESS, get_palf_env(server_idx, palf_env));
191
  EXPECT_EQ(OB_SUCCESS, update_disk_options(16));
192
  EXPECT_EQ(PalfDiskOptionsWrapper::Status::NORMAL_STATUS,
193
            palf_env->palf_env_impl_.disk_options_wrapper_.status_);
194
  EXPECT_EQ(palf_env->palf_env_impl_.disk_options_wrapper_.disk_opts_for_stopping_writing_.log_disk_usage_limit_size_,
195
            16*PALF_PHY_BLOCK_SIZE);
196
  int64_t tmp_id1 = ATOMIC_AAF(&palf_id_, 1);
197
  {
198
    PalfHandleImplGuard leader;
199
    EXPECT_EQ(OB_SUCCESS, create_paxos_group(tmp_id1, leader_idx, leader));
200
  }
201
  int64_t tmp_id2 = ATOMIC_AAF(&palf_id_, 1);
202
  {
203
    PalfHandleImplGuard leader;
204
    EXPECT_EQ(OB_SUCCESS, create_paxos_group(tmp_id2, leader_idx, leader));
205
  }
206
  EXPECT_EQ(OB_NOT_SUPPORTED, update_disk_options(9));
207
  EXPECT_EQ(OB_SUCCESS, delete_paxos_group(tmp_id1));
208
}
209

210
TEST_F(TestObSimpleLogDiskMgr, update_disk_options_restart)
211
{
212
  disable_hot_cache_ = true;
213
  SET_CASE_LOG_FILE(TEST_NAME, "update_disk_options_restart");
214
  OB_LOGGER.set_log_level("INFO");
215
  // 扩容操作
216
  EXPECT_EQ(OB_SUCCESS, update_disk_options(10*1024*1024*1024ul/PALF_PHY_BLOCK_SIZE));
217
  usleep(1000*1000+palf::BlockGCTimerTask::BLOCK_GC_TIMER_INTERVAL_MS);
218
  const int64_t id = ATOMIC_AAF(&palf_id_, 1);
219
  int64_t leader_idx = 0;
220
  PalfEnv *palf_env = NULL;
221
  {
222
    PalfHandleImplGuard leader;
223
    EXPECT_EQ(OB_SUCCESS, create_paxos_group(id, leader_idx, leader));
224
    {
225
      PalfDiskOptions opts;
226
      EXPECT_EQ(OB_SUCCESS, get_disk_options(leader_idx, opts));
227
      EXPECT_EQ(opts.log_disk_usage_limit_size_, 10*1024*1024*1024ul);
228
    }
229
    EXPECT_EQ(OB_SUCCESS, get_palf_env(leader_idx, palf_env));
230
    {
231
      EXPECT_EQ(PalfDiskOptionsWrapper::Status::NORMAL_STATUS,
232
                palf_env->palf_env_impl_.disk_options_wrapper_.status_);
233
      EXPECT_EQ(10*1024*1024*1024ul,
234
                palf_env->palf_env_impl_.disk_options_wrapper_.disk_opts_for_recycling_blocks_.log_disk_usage_limit_size_);
235
    }
236
    // 产生10个文件的数据
237
    EXPECT_EQ(OB_SUCCESS, submit_log(leader, 10*32, id, MAX_LOG_BODY_SIZE));
238
    EXPECT_EQ(OB_SUCCESS, wait_until_has_committed(leader, leader.palf_handle_impl_->get_max_lsn()));
239
    // 最小的log_disk_size要求是存在8个日志文件
240
    EXPECT_EQ(OB_SUCCESS, update_disk_options(leader_idx, 8));
241
    usleep(1000*1000+palf::BlockGCTimerTask::BLOCK_GC_TIMER_INTERVAL_MS);
242
    // 宕机前，缩容不会正式生效，因此不会导致停写
243
    EXPECT_EQ(true, palf_env->palf_env_impl_.diskspace_enough_);
244
    EXPECT_EQ(PalfDiskOptionsWrapper::Status::SHRINKING_STATUS,
245
              palf_env->palf_env_impl_.disk_options_wrapper_.status_);
246
    EXPECT_EQ(10*1024*1024*1024ul, palf_env->palf_env_impl_.disk_options_wrapper_.disk_opts_for_stopping_writing_.log_disk_usage_limit_size_);
247
    int64_t log_disk_usage, total_log_disk_size;
248
    EXPECT_EQ(OB_SUCCESS, palf_env->palf_env_impl_.get_disk_usage(log_disk_usage, total_log_disk_size));
249
    PALF_LOG(INFO, "log_disk_usage:", K(log_disk_usage), K(total_log_disk_size));
250
    // 缩容未成功前，log_disk_usage_limit_size_依旧保持10G.
251
    // 本地持久化的log_disk_size为10G
252
    // 内部表中持久化的log_disk_size为8*PALF_PHY_BLOCK_SIZE
253
    PalfDiskOptions opts;
254
    EXPECT_EQ(OB_SUCCESS, get_disk_options(leader_idx, opts));
255
    EXPECT_EQ(opts.log_disk_usage_limit_size_, 10*1024*1024*1024ul);
256
  }
257
  // 物理缩容未成功前，宕机重启预期不会停写
258
  EXPECT_EQ(OB_SUCCESS, restart_paxos_groups());
259
  {
260
    // 内部表中持久化的log_disk_size依旧是8*PALF_PHY_BLOCK_SIZE
261
    // 重启后继续缩容
262
    int64_t log_disk_usage, total_log_disk_size;
263
    EXPECT_EQ(OB_SUCCESS, get_palf_env(leader_idx, palf_env));
264
    usleep(2*ObLooper::INTERVAL_US);
265
    usleep(2*1000*1000 + BlockGCTimerTask::BLOCK_GC_TIMER_INTERVAL_MS);
266
    EXPECT_EQ(true, palf_env->palf_env_impl_.diskspace_enough_);
267
    EXPECT_EQ(PalfDiskOptionsWrapper::Status::SHRINKING_STATUS,
268
              palf_env->palf_env_impl_.disk_options_wrapper_.status_);
269
    // 本地持久化的（slog）记录的依旧是10G，因此不会停写
270
    EXPECT_EQ(10*1024*1024*1024ul, palf_env->palf_env_impl_.disk_options_wrapper_.disk_opts_for_stopping_writing_.log_disk_usage_limit_size_);
271
    EXPECT_EQ(OB_SUCCESS, palf_env->palf_env_impl_.get_disk_usage(log_disk_usage, total_log_disk_size));
272
    PALF_LOG(INFO, "log_disk_usage:", K(log_disk_usage), K(total_log_disk_size));
273
    PalfDiskOptions opts;
274
    EXPECT_EQ(OB_SUCCESS, get_disk_options(leader_idx, opts));
275
    EXPECT_EQ(opts.log_disk_usage_limit_size_, 10*1024*1024*1024ul);
276
  }
277
  {
278
    PalfHandleImplGuard leader;
279
    EXPECT_EQ(OB_SUCCESS, get_leader(id, leader, leader_idx));
280
    PalfDiskOptions opts;
281
    EXPECT_EQ(OB_SUCCESS, get_disk_options(leader_idx, opts));
282
    EXPECT_EQ(opts.log_disk_usage_limit_size_, 10*1024*1024*1024ul);
283

284
    // 物理上保证不缩容，内部表中持久化的变为16*PALF_PHY_BLOCK_SIZE, 由于palf的log_disk_size是10G,
285
    // 因此本次对palf是一次缩容操作. 但下一轮GC任务运行时，发现当前的使用的日志盘空间不会导致停写,
286
    // 于是日志盘变为正常状态
287
    EXPECT_EQ(OB_SUCCESS, update_disk_options(leader_idx, 16));
288
    // 在下一轮GC任务运行后，本地持久化的log_disk_size也会变为16*PALF_PHY_BLOCK_SIZE
289
    usleep(2*1000*1000+palf::BlockGCTimerTask::BLOCK_GC_TIMER_INTERVAL_MS);
290
    // 经过一轮GC后，会变为NORMAL_STATUS
291
    EXPECT_EQ(true, palf_env->palf_env_impl_.diskspace_enough_);
292
    EXPECT_EQ(PalfDiskOptionsWrapper::Status::NORMAL_STATUS,
293
              palf_env->palf_env_impl_.disk_options_wrapper_.status_);
294
    EXPECT_EQ(16*PALF_PHY_BLOCK_SIZE,
295
              palf_env->palf_env_impl_.disk_options_wrapper_.disk_opts_for_recycling_blocks_.log_disk_usage_limit_size_);
296
    // 后台线程会完成缩容操作，最终本地持久化的变为16*PALF_PHY_BLOCK_SIZE
297
    usleep(2*1000*1000+ObLooper::INTERVAL_US*2);
298
    EXPECT_EQ(OB_SUCCESS, get_disk_options(leader_idx, opts));
299
    EXPECT_EQ(opts.log_disk_usage_limit_size_, 16*PALF_PHY_BLOCK_SIZE);
300
  }
301
}
302

303
TEST_F(TestObSimpleLogDiskMgr, overshelling)
304
{
305
  disable_hot_cache_ = true;
306
  SET_CASE_LOG_FILE(TEST_NAME, "overshelling");
307
  OB_LOGGER.set_log_level("INFO");
308
  ObServerLogBlockMgr *log_pool = nullptr;
309
  EXPECT_EQ(OB_SUCCESS, get_log_pool(0, log_pool));
310
  ASSERT_NE(nullptr, log_pool);
311
  // 验证扩缩容场景下的LogPool字段的正确性
312
  EXPECT_EQ(16*PALF_PHY_BLOCK_SIZE, log_pool->min_log_disk_size_for_all_tenants_);
313
  const int64_t id = ATOMIC_AAF(&palf_id_, 1);
314
  int64_t leader_idx = 0;
315
  PalfEnv *palf_env = NULL;
316
  {
317
    PalfHandleImplGuard leader;
318
    EXPECT_EQ(OB_SUCCESS, create_paxos_group(id, leader_idx, leader));
319
  }
320
  EXPECT_EQ(OB_SUCCESS, update_disk_options(leader_idx, 15));
321
  int64_t log_disk_size_used_for_tenants = log_pool->min_log_disk_size_for_all_tenants_;
322
  // 缩容还未成功，预期log_disk_size_used_for_tenants一定是16*PALF_PHY_BLOCK_SIZE
323
  PalfDiskOptions opts;
324
  EXPECT_EQ(OB_SUCCESS, get_disk_options(leader_idx, opts));
325
  if (opts.log_disk_usage_limit_size_ == 16*PALF_PHY_BLOCK_SIZE) {
326
    EXPECT_EQ(16*PALF_PHY_BLOCK_SIZE, log_disk_size_used_for_tenants);
327
    // 缩容不会立马生效
328
    usleep(2*1000*1000+ObLooper::INTERVAL_US*2);
329
    EXPECT_EQ(15*PALF_PHY_BLOCK_SIZE, log_pool->min_log_disk_size_for_all_tenants_);
330
  } else {
331
    PALF_LOG(INFO, "update_disk_options successfully", K(log_disk_size_used_for_tenants), K(opts));
332
  }
333

334
  // 扩容预期立马成功
335
  EXPECT_EQ(OB_SUCCESS, update_disk_options(leader_idx, 16));
336
  EXPECT_EQ(OB_SUCCESS, get_disk_options(leader_idx, opts));
337
  EXPECT_EQ(16*PALF_PHY_BLOCK_SIZE, log_disk_size_used_for_tenants);
338
  EXPECT_EQ(16*PALF_PHY_BLOCK_SIZE, opts.log_disk_usage_limit_size_);
339

340
  // 直接扩容为LogPool上限值
341
  const int64_t limit_log_disk_size = log_pool->log_pool_meta_.curr_total_size_;
342
  EXPECT_EQ(OB_SUCCESS, update_disk_options(leader_idx, limit_log_disk_size/PALF_PHY_BLOCK_SIZE));
343
  EXPECT_EQ(OB_SUCCESS, get_disk_options(leader_idx, opts));
344
  log_disk_size_used_for_tenants = log_pool->min_log_disk_size_for_all_tenants_;
345
  EXPECT_EQ(limit_log_disk_size, log_disk_size_used_for_tenants);
346
  EXPECT_EQ(limit_log_disk_size, opts.log_disk_usage_limit_size_);
347

348
  {
349
    PalfHandleImplGuard leader;
350
    EXPECT_EQ(OB_SUCCESS, get_leader(id, leader, leader_idx));
351
    // 生成10个文件
352
    EXPECT_EQ(OB_SUCCESS, submit_log(leader, 10*32, id, MAX_LOG_BODY_SIZE));
353
    EXPECT_EQ(OB_SUCCESS, wait_until_has_committed(leader, leader.palf_handle_impl_->get_max_lsn()));
354
    EXPECT_EQ(OB_SUCCESS, update_disk_options(leader_idx, 10));
355
    // 缩容一定不会成功，租户日志盘规格依旧为上限值
356
    usleep(2*1000*1000+ObLooper::INTERVAL_US * 2);
357
    EXPECT_EQ(OB_SUCCESS, get_palf_env(leader_idx, palf_env));
358
    EXPECT_EQ(PalfDiskOptionsWrapper::Status::SHRINKING_STATUS,
359
              palf_env->palf_env_impl_.disk_options_wrapper_.status_);
360
    EXPECT_EQ(OB_SUCCESS, get_disk_options(leader_idx, opts));
361
    log_disk_size_used_for_tenants = log_pool->min_log_disk_size_for_all_tenants_;
362
    EXPECT_EQ(limit_log_disk_size, log_disk_size_used_for_tenants);
363
    EXPECT_EQ(limit_log_disk_size, opts.log_disk_usage_limit_size_);
364
    EXPECT_EQ(OB_MACHINE_RESOURCE_NOT_ENOUGH, log_pool->create_tenant(MIN_DISK_SIZE_PER_PALF_INSTANCE));
365
    const LSN base_lsn(8*PALF_BLOCK_SIZE);
366
    EXPECT_EQ(OB_SUCCESS, leader.palf_handle_impl_->set_base_lsn(base_lsn));
367
    usleep(1000);
368
    EXPECT_EQ(OB_SUCCESS, submit_log(leader, 1, id, 1000));
369
    EXPECT_EQ(OB_SUCCESS, wait_lsn_until_flushed(leader.palf_handle_impl_->get_max_lsn(), leader));
370
    EXPECT_EQ(OB_SUCCESS, wait_until_disk_space_to(leader_idx, (10*PALF_PHY_BLOCK_SIZE*80+100)/100));
371
    usleep(ObLooper::INTERVAL_US * 2);
372
    EXPECT_EQ(PalfDiskOptionsWrapper::Status::NORMAL_STATUS,
373
              palf_env->palf_env_impl_.disk_options_wrapper_.status_);
374
    EXPECT_EQ(OB_SUCCESS, get_disk_options(leader_idx, opts));
375
    log_disk_size_used_for_tenants = log_pool->min_log_disk_size_for_all_tenants_;
376
    EXPECT_EQ(10*PALF_PHY_BLOCK_SIZE, log_disk_size_used_for_tenants);
377
    EXPECT_EQ(10*PALF_PHY_BLOCK_SIZE, opts.log_disk_usage_limit_size_);
378
    EXPECT_EQ(OB_SUCCESS, log_pool->create_tenant(MIN_DISK_SIZE_PER_PALF_INSTANCE));
379
    log_pool->abort_create_tenant(MIN_DISK_SIZE_PER_PALF_INSTANCE);
380

381
    // 扩容预计一定成功
382
    EXPECT_EQ(OB_SUCCESS, update_disk_options(leader_idx, limit_log_disk_size/PALF_PHY_BLOCK_SIZE));
383
    EXPECT_EQ(PalfDiskOptionsWrapper::Status::NORMAL_STATUS,
384
              palf_env->palf_env_impl_.disk_options_wrapper_.status_);
385
    EXPECT_EQ(OB_SUCCESS, get_disk_options(leader_idx, opts));
386
    log_disk_size_used_for_tenants = log_pool->min_log_disk_size_for_all_tenants_;
387
    EXPECT_EQ(limit_log_disk_size, log_disk_size_used_for_tenants);
388
    EXPECT_EQ(limit_log_disk_size, opts.log_disk_usage_limit_size_);
389
    EXPECT_EQ(OB_MACHINE_RESOURCE_NOT_ENOUGH, log_pool->create_tenant(MIN_DISK_SIZE_PER_PALF_INSTANCE));
390

391
  }
392

393
}
394

395
TEST_F(TestObSimpleLogDiskMgr, hidden_sys)
396
{
397
  SET_CASE_LOG_FILE(TEST_NAME, "hidden_sys");
398
  int server_idx = 0;
399
  PalfEnv *palf_env = NULL;
400
  int64_t leader_idx = 0;
401
  int64_t id = ATOMIC_AAF(&palf_id_, 1);
402
  int64_t total_used_size = 0, total_size = 0;
403
  share::SCN create_scn = share::SCN::base_scn();
404
  EXPECT_EQ(OB_SUCCESS, get_palf_env(0, palf_env));
405
  {
406
    PalfHandleImplGuard leader;
407
    EXPECT_EQ(OB_SUCCESS, palf_env->get_stable_disk_usage(total_used_size, total_size));
408
    EXPECT_EQ(0, total_used_size);
409
    EXPECT_EQ(OB_SUCCESS, create_paxos_group(id, create_scn, leader_idx, leader));
410
    EXPECT_EQ(OB_SUCCESS, palf_env->get_stable_disk_usage(total_used_size, total_size));
411
    EXPECT_NE(0, total_used_size);
412
    EXPECT_EQ(OB_NOT_SUPPORTED, update_disk_options(0));
413
  }
414
  EXPECT_EQ(OB_SUCCESS, delete_paxos_group(id));
415
  EXPECT_EQ(OB_SUCCESS, update_disk_options(0));
416
  // tenant unit中记录的disk_opts直接生效
417
  PalfDiskOptions disk_opts;
418
  EXPECT_EQ(OB_SUCCESS, get_disk_options(0, disk_opts));
419
  EXPECT_EQ(0, disk_opts.log_disk_usage_limit_size_);
420
  EXPECT_EQ(PalfDiskOptionsWrapper::Status::SHRINKING_STATUS,
421
            palf_env->palf_env_impl_.disk_options_wrapper_.status_);
422
  usleep(palf::BlockGCTimerTask::BLOCK_GC_TIMER_INTERVAL_MS + 5*100000);
423
  usleep(ObLooper::INTERVAL_US * 2);
424
  EXPECT_EQ(PalfDiskOptionsWrapper::Status::NORMAL_STATUS,
425
            palf_env->palf_env_impl_.disk_options_wrapper_.status_);
426
  EXPECT_EQ(OB_SUCCESS, palf_env->get_stable_disk_usage(total_used_size, total_size));
427
  EXPECT_EQ(0, total_used_size);
428
  EXPECT_EQ(0, total_size);
429
  EXPECT_EQ(OB_SUCCESS, update_disk_options(8));
430
  PalfHandleImplGuard leader;
431
  EXPECT_EQ(OB_SUCCESS, create_paxos_group(id, create_scn, leader_idx, leader));
432
  EXPECT_EQ(OB_SUCCESS, palf_env->get_stable_disk_usage(total_used_size, total_size));
433
  EXPECT_NE(0, total_used_size);
434
}
435

436
} // namespace unittest
437
} // namespace oceanbase
438

439
int main(int argc, char **argv)
440
{
441
  RUN_SIMPLE_LOG_CLUSTER_TEST(TEST_NAME);
442
}
443