oceanbase

test_table_sess_pool.cpp
247 строк · 8.2 Кб
Перенос по словам
1
/**
2
 * Copyright (c) 2023 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 <gtest/gtest.h>
14
#define private public  // 获取私有成员
15
#include "observer/table/ob_table_session_pool.h"
16
#include "lib/utility/ob_test_util.h"
17
#include "share/ob_thread_pool.h"
18
#include "mtlenv/mock_tenant_module_env.h"
19
#include "share/rc/ob_tenant_base.h"
20

21
using namespace oceanbase;
22
using namespace oceanbase::common;
23
using namespace oceanbase::table;
24
using namespace oceanbase::sql;
25
using namespace oceanbase::share;
26
using namespace oceanbase::storage;
27

28
class TestTableSessPool: public ::testing::Test
29
{
30
public:
31
  TestTableSessPool() {}
32
  virtual ~TestTableSessPool() {}
33
  static void SetUpTestCase()
34
  {
35
    EXPECT_EQ(OB_SUCCESS, MockTenantModuleEnv::get_instance().init());
36
  }
37
  static void TearDownTestCase()
38
  {
39
    MockTenantModuleEnv::get_instance().destroy();
40
  }
41
  void SetUp()
42
  {
43
    ASSERT_TRUE(MockTenantModuleEnv::get_instance().is_inited());
44
    TABLEAPI_SESS_POOL_MGR->init();
45
    create_credential(1, mock_cred_);
46
  }
47
  void TearDown()
48
  {
49
    TABLEAPI_SESS_POOL_MGR->destroy();
50
  }
51
private:
52
  void create_credential(uint64_t user_id, ObTableApiCredential *&cred);
53
private:
54
  ObArenaAllocator allocator_;
55
  ObTableApiCredential *mock_cred_;
56
  // disallow copy
57
  DISALLOW_COPY_AND_ASSIGN(TestTableSessPool);
58
};
59

60
void TestTableSessPool::create_credential(uint64_t user_id, ObTableApiCredential *&cred)
61
{
62
  void *buf = nullptr;
63
  buf = allocator_.alloc(sizeof(ObTableApiCredential));
64
  cred = new (buf) ObTableApiCredential();
65
  cred->cluster_id_ = 0;
66
  cred->tenant_id_ = 1;
67
  cred->user_id_ = user_id;
68
  cred->database_id_ = 1;
69
  cred->expire_ts_ = 0;
70
  cred->hash(cred->hash_val_);
71
}
72

73
TEST_F(TestTableSessPool, test_mgr_init)
74
{
75
  ObTableApiSessPoolMgr mgr;
76
  ASSERT_FALSE(mgr.is_inited_);
77
  ASSERT_EQ(nullptr, mgr.pool_);
78
  ASSERT_EQ(nullptr, mgr.elimination_task_.sess_pool_mgr_);
79

80
  ASSERT_EQ(OB_SYS_TENANT_ID, MTL_ID());
81
  ASSERT_TRUE(TABLEAPI_SESS_POOL_MGR->is_inited_);
82
  ASSERT_EQ(nullptr, TABLEAPI_SESS_POOL_MGR->pool_);
83
  ASSERT_EQ(TABLEAPI_SESS_POOL_MGR, TABLEAPI_SESS_POOL_MGR->elimination_task_.sess_pool_mgr_);
84
}
85

86
TEST_F(TestTableSessPool, test_pool_init)
87
{
88
  ObTableApiSessPool pool;
89
  ASSERT_FALSE(pool.is_inited_);
90
  ASSERT_TRUE(pool.key_node_map_.empty());
91
  ASSERT_TRUE(pool.retired_nodes_.is_empty());
92
}
93

94
TEST_F(TestTableSessPool, test_node_init)
95
{
96
  ObTableApiSessNode node(*mock_cred_);
97
  ASSERT_TRUE(node.sess_lists_.free_list_.is_empty());
98
  ASSERT_TRUE(node.sess_lists_.used_list_.is_empty());
99
  ASSERT_EQ(0, node.last_active_ts_);
100
}
101

102
TEST_F(TestTableSessPool, test_node_val_init)
103
{
104
  ObTableApiSessNode node(*mock_cred_);
105
  ObTableApiSessNodeVal val(&node, MTL_ID());
106
  ASSERT_FALSE(val.is_inited_);
107
  ASSERT_EQ(&node, val.owner_node_);
108
}
109

110
TEST_F(TestTableSessPool, test_sess_guard_init)
111
{
112
  ObTableApiSessGuard guard;
113
  ASSERT_EQ(nullptr, guard.sess_node_val_);
114
}
115

116
TEST_F(TestTableSessPool, mgr_get_session)
117
{
118
  ASSERT_EQ(OB_SYS_TENANT_ID, MTL_ID());
119
  ObTableApiSessPoolMgr *mgr = TABLEAPI_SESS_POOL_MGR;
120

121
  // first time will create a new node
122
  ASSERT_EQ(OB_SUCCESS, mgr->update_sess(*mock_cred_));
123
  ASSERT_NE(nullptr, mgr->pool_);
124
  ASSERT_TRUE(mgr->pool_->is_inited_);
125
  ASSERT_EQ(1, mgr->pool_->key_node_map_.size());
126
  ASSERT_EQ(0, mgr->pool_->retired_nodes_.size_);
127
  ObTableApiSessNode *node;
128
  ASSERT_EQ(OB_SUCCESS, mgr->pool_->get_sess_node(mock_cred_->hash_val_, node));
129
  ASSERT_NE(nullptr, node);
130
  ASSERT_TRUE(node->sess_lists_.free_list_.is_empty());
131
  ASSERT_TRUE(node->sess_lists_.used_list_.is_empty());
132
  ASSERT_NE(0, node->last_active_ts_);
133

134
  // add mock val to node
135
  ObTableApiSessNodeVal val(node, MTL_ID());
136
  val.is_inited_ = true;
137
  ASSERT_EQ(true, node->sess_lists_.free_list_.add_last(&val));
138

139
  ObTableApiSessGuard guard;
140
  ASSERT_EQ(OB_SUCCESS, mgr->get_sess_info(*mock_cred_, guard));
141
  ASSERT_NE(nullptr, guard.sess_node_val_);
142
  ASSERT_NE(nullptr, guard.get_sess_node_val());
143
  const ObTableApiCredential *cred = nullptr;
144
  ASSERT_EQ(OB_SUCCESS, guard.get_credential(cred));
145
  ASSERT_NE(nullptr, cred);
146
  mgr->destroy();
147
}
148

149
TEST_F(TestTableSessPool, mgr_update_session)
150
{
151
  ASSERT_EQ(OB_SYS_TENANT_ID, MTL_ID());
152
  ObTableApiSessPoolMgr *mgr = TABLEAPI_SESS_POOL_MGR;
153
  // first time will create a new node
154
  ASSERT_EQ(OB_SUCCESS, mgr->update_sess(*mock_cred_));
155
  ASSERT_NE(nullptr, mgr->pool_);
156
  ASSERT_TRUE(mgr->pool_->is_inited_);
157
  ASSERT_EQ(1, mgr->pool_->key_node_map_.size());
158
  ASSERT_EQ(0, mgr->pool_->retired_nodes_.size_);
159
  ObTableApiSessNode *node;
160
  ASSERT_EQ(OB_SUCCESS, mgr->pool_->get_sess_node(mock_cred_->hash_val_, node));
161
  ASSERT_NE(nullptr, node);
162
  ASSERT_TRUE(node->sess_lists_.free_list_.is_empty());
163
  ASSERT_TRUE(node->sess_lists_.used_list_.is_empty());
164
  ASSERT_NE(0, node->last_active_ts_);
165
  // second time will do replace
166
  ObTableApiCredential *new_cred = nullptr;
167
  create_credential(1, new_cred);
168
  ASSERT_NE(nullptr, new_cred);
169
  ASSERT_EQ(OB_SUCCESS, mgr->update_sess(*new_cred));
170
  ASSERT_NE(nullptr, mgr->pool_);
171
  ASSERT_TRUE(mgr->pool_->is_inited_);
172
  ASSERT_EQ(1, mgr->pool_->key_node_map_.size());
173
  ASSERT_EQ(0, mgr->pool_->retired_nodes_.size_);
174
  ASSERT_EQ(OB_SUCCESS, mgr->pool_->get_sess_node(new_cred->hash_val_, node));
175
  ASSERT_NE(nullptr, node);
176
  ASSERT_TRUE(node->sess_lists_.free_list_.is_empty());
177
  ASSERT_TRUE(node->sess_lists_.used_list_.is_empty());
178
  ASSERT_NE(0, node->last_active_ts_);
179
  // update another key is 2 node.
180
  create_credential(2, new_cred);
181
  ASSERT_NE(nullptr, new_cred);
182
  ASSERT_EQ(OB_SUCCESS, mgr->update_sess(*new_cred));
183
  ASSERT_NE(nullptr, mgr->pool_);
184
  ASSERT_TRUE(mgr->pool_->is_inited_);
185
  ASSERT_EQ(2, mgr->pool_->key_node_map_.size());
186
  ASSERT_EQ(0, mgr->pool_->retired_nodes_.size_);
187
  ASSERT_EQ(OB_SUCCESS, mgr->pool_->get_sess_node(new_cred->hash_val_, node));
188
  ASSERT_NE(nullptr, node);
189
  ASSERT_TRUE(node->sess_lists_.free_list_.is_empty());
190
  ASSERT_TRUE(node->sess_lists_.used_list_.is_empty());
191
  ASSERT_NE(0, node->last_active_ts_);
192
}
193

194
TEST_F(TestTableSessPool, mgr_destroy)
195
{
196
  ASSERT_EQ(OB_SYS_TENANT_ID, MTL_ID());
197
  ObTableApiSessPoolMgr *mgr = TABLEAPI_SESS_POOL_MGR;
198
  ASSERT_EQ(OB_SUCCESS, mgr->update_sess(*mock_cred_));
199
  ASSERT_NE(nullptr, mgr->pool_);
200
  ObTableApiSessNode *node;
201
  ASSERT_EQ(OB_SUCCESS, mgr->pool_->get_sess_node(mock_cred_->hash_val_, node));
202
  mgr->destroy();
203
  ASSERT_FALSE(mgr->is_inited_);
204
  ASSERT_EQ(nullptr, mgr->pool_);
205
  ASSERT_EQ(0, mgr->allocator_.total());
206
  ASSERT_EQ(0, mgr->allocator_.used());
207
}
208

209
TEST_F(TestTableSessPool, mgr_sess_recycle)
210
{
211
  ASSERT_EQ(OB_SYS_TENANT_ID, MTL_ID());
212
  ObTableApiSessPoolMgr *mgr = TABLEAPI_SESS_POOL_MGR;
213
  ASSERT_EQ(OB_SUCCESS, mgr->update_sess(*mock_cred_));
214
  ASSERT_NE(nullptr, mgr->pool_);
215

216
  // add mock val to node
217
  ObTableApiSessNode *node;
218
  ASSERT_EQ(OB_SUCCESS, mgr->pool_->get_sess_node(mock_cred_->hash_val_, node));
219
  ObTableApiSessNodeVal val(node, MTL_ID());
220
  val.is_inited_ = true;
221
  ASSERT_EQ(true, node->sess_lists_.free_list_.add_last(&val));
222

223
  ObTableApiSessGuard guard;
224
  ASSERT_EQ(OB_SUCCESS, mgr->get_sess_info(*mock_cred_, guard));
225
  mgr->elimination_task_.runTimerTask();
226
  ASSERT_EQ(1, mgr->pool_->key_node_map_.size());
227
  ASSERT_EQ(0, mgr->pool_->retired_nodes_.size_);
228
  guard.~ObTableApiSessGuard();
229

230
  // 3min not access
231
  ASSERT_EQ(OB_SUCCESS, mgr->pool_->get_sess_node(mock_cred_->hash_val_, node));
232
  node->last_active_ts_ = node->last_active_ts_ - ObTableApiSessPool::SESS_RETIRE_TIME;
233
  mgr->elimination_task_.run_retire_sess_task();
234
  ASSERT_EQ(0, mgr->pool_->key_node_map_.size());
235
  ASSERT_EQ(1, mgr->pool_->retired_nodes_.size_);
236
  mgr->elimination_task_.run_recycle_retired_sess_task();
237
  ASSERT_EQ(0, mgr->pool_->key_node_map_.size());
238
  ASSERT_EQ(0, mgr->pool_->retired_nodes_.size_);
239
}
240

241
int main(int argc, char **argv)
242
{
243
  OB_LOGGER.set_log_level("INFO");
244
  OB_LOGGER.set_file_name("TestTableSessPool.log", true);
245
  ::testing::InitGoogleTest(&argc,argv);
246
  return RUN_ALL_TESTS();
247
}
248
oceanbase

Использование cookies
