oceanbase

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

17
const std::string TEST_NAME = "single_arb_server";
18

19
using namespace oceanbase::common;
20
using namespace oceanbase;
21
namespace oceanbase
22
{
23
namespace unittest
24
{
25

26
class TestObSimpleMutilArbServer : public ObSimpleLogClusterTestEnv
27
{
28
public:
29
  TestObSimpleMutilArbServer() :  ObSimpleLogClusterTestEnv()
30
  {}
31
};
32

33
int64_t ObSimpleLogClusterTestBase::member_cnt_ = 1;
34
int64_t ObSimpleLogClusterTestBase::node_cnt_ = 1;
35
bool ObSimpleLogClusterTestBase::need_add_arb_server_ = true;
36
std::string ObSimpleLogClusterTestBase::test_name_ = TEST_NAME;
37

38
bool check_dir_exist(const char *base_dir, const int64_t id)
39
{
40
  char dir[OB_MAX_FILE_NAME_LENGTH] = {'\0'};
41
  snprintf(dir, OB_MAX_FILE_NAME_LENGTH, "%s/tenant_%ld", base_dir, id);
42
  int ret = OB_SUCCESS;
43
  bool result = false;
44
  if (OB_FAIL(FileDirectoryUtils::is_exists(dir, result))) {
45
    CLOG_LOG(WARN, "dir is not exist", K(ret), K(errno), K(dir), K(dir));
46
  }
47
  return result;
48
}
49

50
TEST_F(TestObSimpleMutilArbServer, create_mutil_tenant)
51
{
52
  SET_CASE_LOG_FILE(TEST_NAME, "create_mutil_tenant");
53
  OB_LOGGER.set_log_level("TRACE");
54
  ObISimpleLogServer *iserver = get_cluster()[0];
55
  EXPECT_EQ(true, iserver->is_arb_server());
56
  ObSimpleArbServer *arb_server = dynamic_cast<ObSimpleArbServer*>(iserver);
57
  palflite::PalfEnvLiteMgr *palf_env_mgr = &arb_server->palf_env_mgr_;
58
  int64_t cluster_id = 1;
59
  arbserver::GCMsgEpoch epoch = arbserver::GCMsgEpoch(1, 1);
60
  EXPECT_EQ(OB_ARBITRATION_SERVICE_ALREADY_EXIST, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_id, "arbserver_test", epoch));
61
  sleep(2);
62
  CLOG_LOG(INFO, "one tenant");
63
  sleep(2);
64
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->create_palf_env_lite(palflite::PalfEnvKey(cluster_id, 1)));
65
  sleep(2);
66
  CLOG_LOG(INFO, "two tenant");
67
  sleep(2);
68
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->create_palf_env_lite(palflite::PalfEnvKey(cluster_id, 2)));
69
  sleep(2);
70
  CLOG_LOG(INFO, "three tenant");
71
  sleep(2);
72
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->create_palf_env_lite(palflite::PalfEnvKey(cluster_id, 3)));
73
  sleep(2);
74
  CLOG_LOG(INFO, "four tenant");
75
  sleep(2);
76
  {
77
    PalfBaseInfo info_2; info_2.generate_by_default();
78
    AccessMode mode(palf::AccessMode::APPEND);
79
    IPalfHandleImpl *ipalf_handle_impl_2 = NULL;
80
    palflite::PalfEnvLite *palf_env_lite_2 = NULL;
81
    EXPECT_EQ(OB_SUCCESS, palf_env_mgr->palf_env_lite_map_.get(palflite::PalfEnvKey(cluster_id, 2), palf_env_lite_2));
82
    EXPECT_EQ(OB_SUCCESS, palf_env_lite_2->create_palf_handle_impl(1, mode, info_2, ipalf_handle_impl_2));
83
    palf_env_lite_2->revert_palf_handle_impl(ipalf_handle_impl_2);
84
    palf_env_mgr->revert_palf_env_lite(palf_env_lite_2);
85
    CLOG_LOG(INFO, "revert_palf_env_lite2");
86
  }
87
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->remove_palf_env_lite(palflite::PalfEnvKey(cluster_id, 1)));
88
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->remove_palf_env_lite(palflite::PalfEnvKey(cluster_id, 2)));
89
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->remove_palf_env_lite(palflite::PalfEnvKey(cluster_id, 3)));
90
  EXPECT_EQ(false, check_dir_exist(palf_env_mgr->base_dir_, 1));
91
  EXPECT_EQ(false, check_dir_exist(palf_env_mgr->base_dir_, 2));
92
  EXPECT_EQ(false, check_dir_exist(palf_env_mgr->base_dir_, 3));
93
  CLOG_LOG(INFO, "before restart_paxos_groups1");
94
  EXPECT_EQ(OB_SUCCESS, restart_paxos_groups());
95
  auto &map = palf_env_mgr->cluster_meta_info_map_;
96
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->create_palf_env_lite(palflite::PalfEnvKey(cluster_id, 1)));
97
  palflite::ClusterMetaInfo info;
98
  EXPECT_EQ(OB_SUCCESS, map.get_refactored(cluster_id, info));
99
  EXPECT_EQ(2, info.tenant_count_);
100
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->create_palf_env_lite(palflite::PalfEnvKey(cluster_id, 2)));
101
  EXPECT_EQ(OB_SUCCESS, map.get_refactored(cluster_id, info));
102
  EXPECT_EQ(3, info.tenant_count_);
103
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->create_palf_env_lite(palflite::PalfEnvKey(cluster_id, 3)));
104
  EXPECT_EQ(OB_SUCCESS, map.get_refactored(cluster_id, info));
105
  EXPECT_EQ(4, info.tenant_count_);
106
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->create_arbitration_instance(
107
        palflite::PalfEnvKey(cluster_id, 1), arb_server->self_, 1001,
108
        ObTenantRole(ObTenantRole::PRIMARY_TENANT)));
109
  auto update_meta = [](palflite::PalfEnvLiteMgr::MapPair &pair) -> void{
110
    auto &info = pair.second;
111
    info.epoch_ = arbserver::GCMsgEpoch(100, 100);
112
  };
113
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->update_cluster_meta_info_(cluster_id, update_meta));
114
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->get_cluster_meta_info_(cluster_id, info));
115
  EXPECT_EQ(arbserver::GCMsgEpoch(100, 100), info.epoch_);
116
  CLOG_LOG(INFO, "before restart_paxos_groups2");
117
  EXPECT_EQ(OB_SUCCESS, restart_paxos_groups());
118
  {
119
    palflite::PalfEnvLite *palf_env_lite_2 = NULL;
120
    EXPECT_EQ(OB_SUCCESS, palf_env_mgr->palf_env_lite_map_.get(palflite::PalfEnvKey(cluster_id, 2), palf_env_lite_2));
121
    palf_env_mgr->revert_palf_env_lite(palf_env_lite_2);
122
  }
123
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->remove_palf_env_lite(palflite::PalfEnvKey(cluster_id, 1)));
124
  EXPECT_EQ(OB_SUCCESS, map.get_refactored(cluster_id, info));
125
  EXPECT_EQ(3, info.tenant_count_);
126
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->remove_palf_env_lite(palflite::PalfEnvKey(cluster_id, 2)));
127
  EXPECT_EQ(OB_SUCCESS, map.get_refactored(cluster_id, info));
128
  EXPECT_EQ(2, info.tenant_count_);
129
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->remove_palf_env_lite(palflite::PalfEnvKey(cluster_id, 3)));
130
  EXPECT_EQ(OB_SUCCESS, map.get_refactored(cluster_id, info));
131
  EXPECT_EQ(1, info.tenant_count_);
132
  EXPECT_EQ(OB_ENTRY_NOT_EXIST, palf_env_mgr->remove_palf_env_lite(palflite::PalfEnvKey(cluster_id, 1001)));
133
  CLOG_LOG(INFO, "end restart_paxos_groups");
134
}
135

136
TEST_F(TestObSimpleMutilArbServer, out_interface)
137
{
138
  SET_CASE_LOG_FILE(TEST_NAME, "out_interface");
139
  OB_LOGGER.set_log_level("TRACE");
140
  ObISimpleLogServer *iserver = get_cluster()[0];
141
  EXPECT_EQ(true, iserver->is_arb_server());
142
  ObMember member(iserver->get_addr(), 100);
143
  ObSimpleArbServer *arb_server = dynamic_cast<ObSimpleArbServer*>(iserver);
144
  ObTenantRole tenant_role(ObTenantRole::PRIMARY_TENANT);
145
  int64_t cluster_id = 1;
146
  GlobalLearnerList learner_list;
147
  arbserver::GCMsgEpoch epoch = arbserver::GCMsgEpoch(1, 1);
148
  EXPECT_EQ(OB_ARBITRATION_SERVICE_ALREADY_EXIST, arb_server->palf_env_mgr_.add_cluster(
149
            iserver->get_addr(), cluster_id, "arbserver_test", epoch));
150
  EXPECT_EQ(OB_ENTRY_NOT_EXIST, arb_server->palf_env_mgr_.set_initial_member_list(
151
        palflite::PalfEnvKey(cluster_id, 1), arb_server->self_,
152
        1000, get_member_list(), member, get_member_cnt(), learner_list));
153
  EXPECT_EQ(OB_SUCCESS, arb_server->palf_env_mgr_.create_arbitration_instance(
154
        palflite::PalfEnvKey(cluster_id, 1), arb_server->self_,
155
        1000, tenant_role));
156
  EXPECT_EQ(OB_SUCCESS, arb_server->palf_env_mgr_.create_arbitration_instance(
157
        palflite::PalfEnvKey(cluster_id, 1), arb_server->self_,
158
        1000, tenant_role));
159
  EXPECT_EQ(OB_NOT_SUPPORTED, arb_server->palf_env_mgr_.set_initial_member_list(
160
        palflite::PalfEnvKey(cluster_id, 1), arb_server->self_,
161
        1000, get_member_list(), member, get_member_cnt(), learner_list));
162
  ObMemberList member_list = get_member_list();
163
  member_list.add_server(arb_server->self_);
164
  EXPECT_EQ(OB_NOT_SUPPORTED, arb_server->palf_env_mgr_.set_initial_member_list(
165
        palflite::PalfEnvKey(cluster_id, 1), arb_server->self_,
166
        1000, member_list, member, get_member_cnt(), learner_list));
167
  EXPECT_EQ(OB_SUCCESS, arb_server->palf_env_mgr_.delete_arbitration_instance(
168
        palflite::PalfEnvKey(cluster_id, 1), arb_server->self_, 1000));
169
  palflite::PalfEnvLite *palf_env_lite = NULL;
170
  EXPECT_EQ(OB_SUCCESS, arb_server->palf_env_mgr_.get_palf_env_lite(
171
        palflite::PalfEnvKey(cluster_id, OB_SERVER_TENANT_ID), palf_env_lite));
172
  arb_server->palf_env_mgr_.revert_palf_env_lite(palf_env_lite);
173
  EXPECT_EQ(OB_SUCCESS, arb_server->palf_env_mgr_.remove_palf_env_lite(
174
        palflite::PalfEnvKey(cluster_id, OB_SERVER_TENANT_ID)));
175
  EXPECT_EQ(OB_SUCCESS, arb_server->palf_env_mgr_.delete_arbitration_instance(
176
        palflite::PalfEnvKey(cluster_id, 1), arb_server->self_, 1000));
177
  CLOG_LOG(INFO, "end test out_interface");
178
}
179

180
TEST_F(TestObSimpleMutilArbServer, create_mutil_cluster)
181
{
182
  SET_CASE_LOG_FILE(TEST_NAME, "create_mutil_cluster");
183
  OB_LOGGER.set_log_level("TRACE");
184
  ObISimpleLogServer *iserver = get_cluster()[0];
185
  EXPECT_EQ(true, iserver->is_arb_server());
186
  ObSimpleArbServer *arb_server = dynamic_cast<ObSimpleArbServer*>(iserver);
187
  palflite::PalfEnvLiteMgr *palf_env_mgr = &arb_server->palf_env_mgr_;
188
  std::vector<int64_t> cluster_ids = {2, 3, 4, 5, 6, 7};
189
  arbserver::GCMsgEpoch epoch = arbserver::GCMsgEpoch(1, 1);
190

191
  // test add tenant without cluster, generate placeholder
192
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->create_palf_env_lite(palflite::PalfEnvKey(cluster_ids[0], 1)));
193
  EXPECT_TRUE(palf_env_mgr->is_cluster_placeholder_exists(cluster_ids[0]));
194
  EXPECT_EQ(OB_ARBITRATION_SERVICE_ALREADY_EXIST, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[0], "arbserver_test", epoch));
195
  EXPECT_EQ(OB_ARBITRATION_SERVICE_ALREADY_EXIST, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[0], "", epoch));
196
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->remove_cluster(iserver->get_addr(), cluster_ids[0], "", epoch));
197

198
  // test add cluster and restart
199
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[0], "arbserver_test", epoch));
200
  // duplicate add_cluster
201
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[0], "arbserver_test", epoch));
202
  // wrong add_cluster
203
  EXPECT_EQ(OB_ARBITRATION_SERVICE_ALREADY_EXIST, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[0], "arbserver_test1", epoch));
204
  EXPECT_EQ(OB_ARBITRATION_SERVICE_ALREADY_EXIST, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[0], "arbserver_test", arbserver::GCMsgEpoch(1, 0)));
205

206
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[1], "arbserver_test", epoch));
207
  EXPECT_EQ(OB_SUCCESS, restart_paxos_groups());
208
  // re-create cluster, cluster_name match, return OB_SUCCESS
209
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[0], "arbserver_test", epoch));
210
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[1], "arbserver_test", epoch));
211
  // re-create cluster, cluster_name do not match, return OB_SUCCESS
212
  EXPECT_EQ(OB_ARBITRATION_SERVICE_ALREADY_EXIST, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[0], "arbserver_test1", epoch));
213
  EXPECT_EQ(OB_ARBITRATION_SERVICE_ALREADY_EXIST, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[1], "arbserver_test1", epoch));
214

215
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[2], "arbserver_test", epoch));
216
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[3], "arbserver_test", epoch));
217

218
  // empty cluster_name
219
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[4], "", epoch));
220
  EXPECT_EQ(OB_ARBITRATION_SERVICE_ALREADY_EXIST, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[4], "test", epoch));
221

222
  // long cluster_name
223
  char *long_cluster_name = new char[OB_MAX_CLUSTER_NAME_LENGTH + 1];
224
  MEMSET(long_cluster_name, '\0', OB_MAX_CLUSTER_NAME_LENGTH + 1);
225
  MEMSET(long_cluster_name, 'a', OB_MAX_CLUSTER_NAME_LENGTH);
226
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[5], long_cluster_name, epoch));
227
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[5], long_cluster_name, epoch));
228
  EXPECT_TRUE(palf_env_mgr->is_cluster_placeholder_exists(cluster_ids[0]));
229
  EXPECT_EQ(OB_SUCCESS, restart_paxos_groups());
230
  EXPECT_TRUE(palf_env_mgr->is_cluster_placeholder_exists(cluster_ids[0]));
231
  palflite::ClusterMetaInfo long_cluster_meta_info;
232
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->get_cluster_meta_info_(cluster_ids[5], long_cluster_meta_info));
233
  EXPECT_EQ(0, strcmp(long_cluster_name, long_cluster_meta_info.cluster_name_));
234
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->remove_cluster(iserver->get_addr(), cluster_ids[5], long_cluster_name, epoch));
235

236
  // test remove_cluster
237
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->remove_cluster(iserver->get_addr(), cluster_ids[0], "arbserver_test", epoch));
238
  // duplicate remove_cluster
239
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->remove_cluster(iserver->get_addr(), cluster_ids[0], "arbserver_test", epoch));
240

241
  // remove_cluster with wrong cluster_name, still success
242
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->remove_cluster(iserver->get_addr(), cluster_ids[1], "arbserver_test1", epoch));
243

244
  // improve epoch and remove cluster
245
  arbserver::GCMsgEpoch improved_epoch = arbserver::GCMsgEpoch(2, 1);
246
  arbserver::TenantLSIDSArray ls_ids;
247
  ls_ids.set_max_tenant_id(UINT64_MAX);
248
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->handle_gc_message_(improved_epoch, iserver->get_addr(), cluster_ids[2], ls_ids));
249
  EXPECT_EQ(OB_OP_NOT_ALLOW, palf_env_mgr->remove_cluster(iserver->get_addr(), cluster_ids[2], "arbserver_test", epoch));
250
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->remove_cluster(iserver->get_addr(), cluster_ids[2], "arbserver_test", improved_epoch));
251

252
  // normal remove_cluster
253
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->remove_cluster(iserver->get_addr(), cluster_ids[1], "arbserver_test", epoch));
254
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->remove_cluster(iserver->get_addr(), cluster_ids[3], "arbserver_test", epoch));
255
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->remove_cluster(iserver->get_addr(), cluster_ids[4], "", epoch));
256

257
  // test upgrade arbserver, cluster 2 has a tenant and cluster 3 do not
258
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[0], "arbserver_test", epoch));
259
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->add_cluster(iserver->get_addr(), cluster_ids[1], "arbserver_test", epoch));
260
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->create_palf_env_lite(palflite::PalfEnvKey(cluster_ids[0], 1)));
261
  EXPECT_TRUE(palf_env_mgr->is_cluster_placeholder_exists(cluster_ids[0]));
262
  EXPECT_TRUE(palf_env_mgr->is_cluster_placeholder_exists(cluster_ids[1]));
263

264
  std::string cluster_dir1 = palf_env_mgr->base_dir_;
265
  cluster_dir1 += "/cluster_2_clustername_arbserver_test";
266
  cluster_dir1 = "rm -rf " + cluster_dir1;
267
  std::string cluster_dir2 = palf_env_mgr->base_dir_;
268
  cluster_dir2 += "/cluster_3_clustername_arbserver_test";
269
  cluster_dir2 = "rm -rf " + cluster_dir2;
270
  SERVER_LOG(INFO, "delete cluster placeholder manually", K(cluster_dir1.c_str()), K(cluster_dir2.c_str()));
271

272
  system(cluster_dir1.c_str());
273
  system(cluster_dir2.c_str());
274
  EXPECT_FALSE(palf_env_mgr->is_cluster_placeholder_exists(cluster_ids[0]));
275
  EXPECT_FALSE(palf_env_mgr->is_cluster_placeholder_exists(cluster_ids[1]));
276

277
  // restart and regenerate cluster placeholder dir for cluster 2
278
  EXPECT_EQ(OB_SUCCESS, restart_paxos_groups());
279

280
  EXPECT_TRUE(palf_env_mgr->is_cluster_placeholder_exists(cluster_ids[0]));
281
  EXPECT_FALSE(palf_env_mgr->is_cluster_placeholder_exists(cluster_ids[1]));
282

283
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->remove_cluster(iserver->get_addr(), cluster_ids[0], "arbserver_test", epoch));
284
  EXPECT_FALSE(palf_env_mgr->is_cluster_placeholder_exists(cluster_ids[0]));
285
}
286

287
TEST_F(TestObSimpleMutilArbServer, restart_arb)
288
{
289
  SET_CASE_LOG_FILE(TEST_NAME, "restart_arb");
290
  OB_LOGGER.set_log_level("TRACE");
291
  ObISimpleLogServer *iserver = get_cluster()[0];
292
  EXPECT_EQ(true, iserver->is_arb_server());
293
  ObSimpleArbServer *arb_server = dynamic_cast<ObSimpleArbServer*>(iserver);
294
  palflite::PalfEnvLiteMgr *palf_env_mgr = &arb_server->palf_env_mgr_;
295
  std::vector<int64_t> cluster_ids = {2, 3, 4, 5, 6, 7};
296
  arbserver::GCMsgEpoch epoch = arbserver::GCMsgEpoch(1, 1);
297

298
  // test add tenant without cluster, generate placeholder
299
  EXPECT_EQ(OB_SUCCESS, palf_env_mgr->create_palf_env_lite(palflite::PalfEnvKey(cluster_ids[0], 1)));
300
  EXPECT_TRUE(palf_env_mgr->is_cluster_placeholder_exists(cluster_ids[0]));
301

302
  palflite::PalfEnvLite *palf_env_lite = NULL;
303
  IPalfHandleImpl *ipalf_handle_impl = NULL;
304
  {
305
    PalfBaseInfo info; info.generate_by_default();
306
    AccessMode mode(palf::AccessMode::APPEND);
307
    EXPECT_EQ(OB_SUCCESS, palf_env_mgr->get_palf_env_lite(palflite::PalfEnvKey(cluster_ids[0], 1), palf_env_lite));
308
    EXPECT_EQ(OB_SUCCESS, palf_env_lite->create_palf_handle_impl(1, mode, info, ipalf_handle_impl));
309
    palflite::PalfHandleLite *palf_handle_lite = dynamic_cast<palflite::PalfHandleLite*>(ipalf_handle_impl);
310
    ASSERT_NE(nullptr, palf_handle_lite);
311
    LogEngine *log_engine = &palf_handle_lite->log_engine_;
312
    LogMeta log_meta = log_engine->log_meta_;
313
    int count = (2 * 1024 * 1024 - log_engine->log_meta_storage_.log_tail_.val_) / 4096;
314
    while (count > 0) {
315
      EXPECT_EQ(OB_SUCCESS, log_engine->append_log_meta_(log_meta));
316
      count --;
317
    }
318
    while (log_engine->log_meta_storage_.log_tail_ != LSN(2*1024*1024)) {
319
      sleep(1);
320
    }
321
    sleep(1);
322
    EXPECT_EQ(2*1024*1024, log_engine->log_meta_storage_.log_tail_);
323
    EXPECT_EQ(OB_SUCCESS, log_engine->log_meta_storage_.block_mgr_.switch_next_block(1));
324
  }
325
  palf_env_lite->revert_palf_handle_impl(ipalf_handle_impl);
326
  palf_env_mgr->revert_palf_env_lite(palf_env_lite);
327
  EXPECT_EQ(OB_SUCCESS, restart_server(0));
328
}
329

330
} // end unittest
331
} // end oceanbase
332

333
int main(int argc, char **argv)
334
{
335
  RUN_SIMPLE_LOG_CLUSTER_TEST(TEST_NAME);
336
}
337