Skip to content

Commit b64f2e6

Browse files
scotthartscotthart
committed
add more tests
1 parent 2194531 commit b64f2e6

File tree

2 files changed

+135
-7
lines changed

2 files changed

+135
-7
lines changed

‎google/cloud/bigtable/internal/dynamic_channel_pool.h‎

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -259,7 +259,6 @@ class DynamicChannelPool
259259
bad_channel_iters);
260260

261261
std::shared_ptr<ChannelUsage<T>> channel;
262-
263262
if (d.channel_1_rpcs.ok() && d.channel_2_rpcs.ok()) {
264263
channel = *d.channel_1_rpcs < *d.channel_2_rpcs ? *d.channel_1_iter
265264
: *d.channel_2_iter;
@@ -277,7 +276,6 @@ class DynamicChannelPool
277276
std::swap(channels_.front(), channels_.back());
278277
channel = channels_.front();
279278
}
280-
281279
// Wait until we no longer need valid iterators to call EvictBadChannels.
282280
EvictBadChannels(lk, bad_channel_iters);
283281
ScheduleRemoveChannels(lk);
@@ -446,7 +444,6 @@ class DynamicChannelPool
446444
return a + (rpcs_b.ok() ? *rpcs_b : 0);
447445
}) /
448446
static_cast<int>(channels_.size() + num_pending_channels_);
449-
450447
if (channels_.size() < sizing_policy_.minimum_channel_pool_size ||
451448
(average_rpcs_per_channel >
452449
sizing_policy_.maximum_average_outstanding_rpcs_per_channel &&

‎google/cloud/bigtable/internal/dynamic_channel_pool_test.cc‎

Lines changed: 135 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -777,7 +777,6 @@ TEST_F(DynamicChannelPoolTest, HandleBadChannelsTwoChannelsOneBad) {
777777
Eq(std::chrono::nanoseconds(
778778
sizing_policy.pool_size_decrease_cooldown_interval)
779779
.count()));
780-
// return make_ready_future(StatusOr(std::chrono::system_clock::now()));
781780
return cq_.MakeRelativeTimer(std::chrono::seconds(600));
782781
})
783782
// HandleBadChannels will call ScheduleRemoveChannels.
@@ -864,7 +863,6 @@ TEST_F(DynamicChannelPoolTest, HandleBadChannelsTwoChannelsOtherOneBad) {
864863
Eq(std::chrono::nanoseconds(
865864
sizing_policy.pool_size_decrease_cooldown_interval)
866865
.count()));
867-
// return make_ready_future(StatusOr(std::chrono::system_clock::now()));
868866
return cq_.MakeRelativeTimer(std::chrono::seconds(600));
869867
})
870868
// HandleBadChannels will call ScheduleRemoveChannels.
@@ -949,7 +947,6 @@ TEST_F(DynamicChannelPoolTest, HandleBadChannelsThreeChannelsOneBad) {
949947
Eq(std::chrono::nanoseconds(
950948
sizing_policy.pool_size_decrease_cooldown_interval)
951949
.count()));
952-
// return make_ready_future(StatusOr(std::chrono::system_clock::now()));
953950
return cq_.MakeRelativeTimer(std::chrono::seconds(600));
954951
})
955952
// HandleBadChannels will call ScheduleRemoveChannels.
@@ -1040,7 +1037,6 @@ TEST_F(DynamicChannelPoolTest, HandleBadChannelsAllChannelsBad) {
10401037
Eq(std::chrono::nanoseconds(
10411038
sizing_policy.pool_size_decrease_cooldown_interval)
10421039
.count()));
1043-
// return make_ready_future(StatusOr(std::chrono::system_clock::now()));
10441040
return cq_.MakeRelativeTimer(std::chrono::seconds(600));
10451041
})
10461042
// HandleBadChannels will call ScheduleRemoveChannels.
@@ -1120,6 +1116,141 @@ TEST_F(DynamicChannelPoolTest, HandleBadChannelsAllChannelsBad) {
11201116
fake_cq_impl_->SimulateCompletion(false);
11211117
}
11221118

1119+
TEST_F(DynamicChannelPoolTest, CheckChannelPoolHealthNeedsIncrease) {
1120+
auto instance_name =
1121+
bigtable::InstanceResource(Project("my-project"), "my-instance")
1122+
.FullName();
1123+
auto refresh_state = std::make_shared<ConnectionRefreshState>(
1124+
fake_cq_impl_, std::chrono::milliseconds(1),
1125+
std::chrono::milliseconds(10));
1126+
std::vector<std::shared_ptr<ChannelUsage<BigtableStub>>> channels;
1127+
DynamicChannelPoolSizingPolicy sizing_policy;
1128+
1129+
MockFunction<StatusOr<std::shared_ptr<ChannelUsage<BigtableStub>>>(
1130+
std::uint32_t, std::string const&, StubManager::Priming)>
1131+
stub_factory_fn;
1132+
1133+
EXPECT_CALL(*mock_cq_impl_, MakeRelativeTimer)
1134+
// Pool creation should set the pool size increase cooldown timer.
1135+
.WillOnce([&](std::chrono::nanoseconds ns) {
1136+
EXPECT_THAT(ns.count(),
1137+
Eq(std::chrono::nanoseconds(
1138+
sizing_policy.pool_size_decrease_cooldown_interval)
1139+
.count()));
1140+
return cq_.MakeRelativeTimer(std::chrono::seconds(600));
1141+
})
1142+
// Pool creation should set the pool size increase cooldown timer.
1143+
.WillOnce([&](std::chrono::nanoseconds ns) {
1144+
EXPECT_THAT(ns.count(),
1145+
Eq(std::chrono::nanoseconds(
1146+
sizing_policy.pool_size_decrease_cooldown_interval)
1147+
.count()));
1148+
return cq_.MakeRelativeTimer(std::chrono::seconds(600));
1149+
});
1150+
1151+
channels.push_back(std::make_shared<ChannelUsage<BigtableStub>>(
1152+
std::make_shared<MockBigtableStub>(), 30));
1153+
1154+
{
1155+
sizing_policy.minimum_channel_pool_size = 1;
1156+
sizing_policy.maximum_channel_pool_size = 1;
1157+
auto pool = DynamicChannelPool<BigtableStub>::Create(
1158+
instance_name, CompletionQueue(mock_cq_impl_), channels, refresh_state,
1159+
stub_factory_fn.AsStdFunction(), sizing_policy);
1160+
DynamicChannelPoolTestWrapper wrapper(pool);
1161+
1162+
// ScheduleAddChannels will NOT be called as the pool has max channels.
1163+
EXPECT_CALL(*mock_cq_impl_, RunAsync).Times(0);
1164+
auto lock = wrapper.CreateLock();
1165+
wrapper.CheckPoolChannelHealth(lock);
1166+
EXPECT_THAT(wrapper.num_pending_channels(), Eq(0));
1167+
}
1168+
{
1169+
sizing_policy.minimum_channel_pool_size = 2;
1170+
sizing_policy.maximum_channel_pool_size = 10;
1171+
auto pool = DynamicChannelPool<BigtableStub>::Create(
1172+
instance_name, CompletionQueue(mock_cq_impl_), channels, refresh_state,
1173+
stub_factory_fn.AsStdFunction(), sizing_policy);
1174+
DynamicChannelPoolTestWrapper wrapper(pool);
1175+
1176+
// ScheduleAddChannels will be called.
1177+
EXPECT_CALL(*mock_cq_impl_, RunAsync).Times(1);
1178+
auto lock = wrapper.CreateLock();
1179+
wrapper.CheckPoolChannelHealth(lock);
1180+
EXPECT_THAT(wrapper.num_pending_channels(), Eq(1));
1181+
}
1182+
}
1183+
1184+
TEST_F(DynamicChannelPoolTest, CheckChannelPoolHealthNeedsDecrease) {
1185+
auto instance_name =
1186+
bigtable::InstanceResource(Project("my-project"), "my-instance")
1187+
.FullName();
1188+
auto refresh_state = std::make_shared<ConnectionRefreshState>(
1189+
fake_cq_impl_, std::chrono::milliseconds(1),
1190+
std::chrono::milliseconds(10));
1191+
std::vector<std::shared_ptr<ChannelUsage<BigtableStub>>> channels;
1192+
DynamicChannelPoolSizingPolicy sizing_policy;
1193+
1194+
MockFunction<StatusOr<std::shared_ptr<ChannelUsage<BigtableStub>>>(
1195+
std::uint32_t, std::string const&, StubManager::Priming)>
1196+
stub_factory_fn;
1197+
1198+
EXPECT_CALL(*mock_cq_impl_, MakeRelativeTimer)
1199+
// Pool creation should set the pool size increase cooldown timer.
1200+
.WillOnce([&](std::chrono::nanoseconds ns) {
1201+
EXPECT_THAT(ns.count(),
1202+
Eq(std::chrono::nanoseconds(
1203+
sizing_policy.pool_size_decrease_cooldown_interval)
1204+
.count()));
1205+
return make_ready_future(StatusOr(std::chrono::system_clock::now()));
1206+
})
1207+
// ScheduleRemoveChannels should start polling.
1208+
.WillOnce([&](std::chrono::nanoseconds ns) {
1209+
EXPECT_THAT(ns.count(),
1210+
Eq(std::chrono::nanoseconds(
1211+
sizing_policy.remove_channel_polling_interval)
1212+
.count()));
1213+
return cq_.MakeRelativeTimer(std::chrono::seconds(600));
1214+
})
1215+
// ScheduleRemoveChannels should set the pool size increase cooldown
1216+
// timer.
1217+
.WillOnce([&](std::chrono::nanoseconds ns) {
1218+
EXPECT_THAT(ns.count(),
1219+
Eq(std::chrono::nanoseconds(
1220+
sizing_policy.pool_size_decrease_cooldown_interval)
1221+
.count()));
1222+
return cq_.MakeRelativeTimer(std::chrono::seconds(600));
1223+
});
1224+
1225+
channels.push_back(std::make_shared<ChannelUsage<BigtableStub>>(
1226+
std::make_shared<MockBigtableStub>(), 2));
1227+
channels.push_back(std::make_shared<ChannelUsage<BigtableStub>>(
1228+
std::make_shared<MockBigtableStub>(), 2));
1229+
channels.push_back(std::make_shared<ChannelUsage<BigtableStub>>(
1230+
std::make_shared<MockBigtableStub>(), 2));
1231+
channels.push_back(std::make_shared<ChannelUsage<BigtableStub>>(
1232+
std::make_shared<MockBigtableStub>(), 2));
1233+
1234+
sizing_policy.minimum_channel_pool_size = 2;
1235+
sizing_policy.maximum_channel_pool_size = 10;
1236+
sizing_policy.minimum_average_outstanding_rpcs_per_channel = 5;
1237+
auto pool = DynamicChannelPool<BigtableStub>::Create(
1238+
instance_name, CompletionQueue(mock_cq_impl_), channels, refresh_state,
1239+
stub_factory_fn.AsStdFunction(), sizing_policy);
1240+
DynamicChannelPoolTestWrapper wrapper(pool);
1241+
1242+
// ScheduleAddChannels will NOT be called.
1243+
EXPECT_CALL(*mock_cq_impl_, RunAsync).Times(0);
1244+
1245+
{
1246+
auto lock = wrapper.CreateLock();
1247+
wrapper.CheckPoolChannelHealth(lock);
1248+
}
1249+
1250+
EXPECT_THAT(wrapper.num_pending_channels(), Eq(0));
1251+
EXPECT_THAT(pool->size(), Eq(3));
1252+
}
1253+
11231254
} // namespace
11241255
GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
11251256
} // namespace bigtable_internal

0 commit comments

Comments
 (0)