| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/tools/quic/quic_time_wait_list_manager.h" | |
| 6 | |
| 7 #include <errno.h> | |
| 8 | |
| 9 #include "net/quic/crypto/crypto_protocol.h" | |
| 10 #include "net/quic/crypto/null_encrypter.h" | |
| 11 #include "net/quic/crypto/quic_decrypter.h" | |
| 12 #include "net/quic/crypto/quic_encrypter.h" | |
| 13 #include "net/quic/quic_data_reader.h" | |
| 14 #include "net/quic/quic_flags.h" | |
| 15 #include "net/quic/quic_framer.h" | |
| 16 #include "net/quic/quic_packet_writer.h" | |
| 17 #include "net/quic/quic_protocol.h" | |
| 18 #include "net/quic/quic_utils.h" | |
| 19 #include "net/quic/test_tools/quic_test_utils.h" | |
| 20 #include "net/tools/quic/test_tools/mock_epoll_server.h" | |
| 21 #include "net/tools/quic/test_tools/quic_test_utils.h" | |
| 22 #include "testing/gmock/include/gmock/gmock.h" | |
| 23 #include "testing/gtest/include/gtest/gtest.h" | |
| 24 | |
| 25 using net::test::BuildUnsizedDataPacket; | |
| 26 using net::test::NoOpFramerVisitor; | |
| 27 using net::test::QuicVersionMax; | |
| 28 using net::test::QuicVersionMin; | |
| 29 using net::test::ValueRestore; | |
| 30 using testing::Args; | |
| 31 using testing::Assign; | |
| 32 using testing::DoAll; | |
| 33 using testing::Matcher; | |
| 34 using testing::MatcherInterface; | |
| 35 using testing::NiceMock; | |
| 36 using testing::Return; | |
| 37 using testing::ReturnPointee; | |
| 38 using testing::SetArgPointee; | |
| 39 using testing::StrictMock; | |
| 40 using testing::Truly; | |
| 41 using testing::_; | |
| 42 | |
| 43 namespace net { | |
| 44 namespace tools { | |
| 45 namespace test { | |
| 46 | |
| 47 class FramerVisitorCapturingPublicReset : public NoOpFramerVisitor { | |
| 48 public: | |
| 49 FramerVisitorCapturingPublicReset() {} | |
| 50 ~FramerVisitorCapturingPublicReset() override {} | |
| 51 | |
| 52 void OnPublicResetPacket(const QuicPublicResetPacket& public_reset) override { | |
| 53 public_reset_packet_ = public_reset; | |
| 54 } | |
| 55 | |
| 56 const QuicPublicResetPacket public_reset_packet() { | |
| 57 return public_reset_packet_; | |
| 58 } | |
| 59 | |
| 60 private: | |
| 61 QuicPublicResetPacket public_reset_packet_; | |
| 62 }; | |
| 63 | |
| 64 class QuicTimeWaitListManagerPeer { | |
| 65 public: | |
| 66 static bool ShouldSendResponse(QuicTimeWaitListManager* manager, | |
| 67 int received_packet_count) { | |
| 68 return manager->ShouldSendResponse(received_packet_count); | |
| 69 } | |
| 70 | |
| 71 static QuicTime::Delta time_wait_period(QuicTimeWaitListManager* manager) { | |
| 72 return manager->kTimeWaitPeriod_; | |
| 73 } | |
| 74 | |
| 75 static QuicVersion GetQuicVersionFromConnectionId( | |
| 76 QuicTimeWaitListManager* manager, | |
| 77 QuicConnectionId connection_id) { | |
| 78 return manager->GetQuicVersionFromConnectionId(connection_id); | |
| 79 } | |
| 80 }; | |
| 81 | |
| 82 namespace { | |
| 83 | |
| 84 class MockFakeTimeEpollServer : public FakeTimeEpollServer { | |
| 85 public: | |
| 86 MOCK_METHOD2(RegisterAlarm, void(int64 timeout_in_us, | |
| 87 EpollAlarmCallbackInterface* alarm)); | |
| 88 }; | |
| 89 | |
| 90 class QuicTimeWaitListManagerTest : public ::testing::Test { | |
| 91 protected: | |
| 92 QuicTimeWaitListManagerTest() | |
| 93 : time_wait_list_manager_(&writer_, &visitor_, | |
| 94 &epoll_server_, QuicSupportedVersions()), | |
| 95 framer_(QuicSupportedVersions(), QuicTime::Zero(), true), | |
| 96 connection_id_(45), | |
| 97 client_address_(net::test::TestPeerIPAddress(), kTestPort), | |
| 98 writer_is_blocked_(false) {} | |
| 99 | |
| 100 ~QuicTimeWaitListManagerTest() override {} | |
| 101 | |
| 102 void SetUp() override { | |
| 103 EXPECT_CALL(writer_, IsWriteBlocked()) | |
| 104 .WillRepeatedly(ReturnPointee(&writer_is_blocked_)); | |
| 105 EXPECT_CALL(writer_, IsWriteBlockedDataBuffered()) | |
| 106 .WillRepeatedly(Return(false)); | |
| 107 } | |
| 108 | |
| 109 void AddConnectionId(QuicConnectionId connection_id) { | |
| 110 AddConnectionId(connection_id, QuicVersionMax(), nullptr); | |
| 111 } | |
| 112 | |
| 113 void AddConnectionId(QuicConnectionId connection_id, | |
| 114 QuicVersion version, | |
| 115 QuicEncryptedPacket* packet) { | |
| 116 time_wait_list_manager_.AddConnectionIdToTimeWait( | |
| 117 connection_id, version, packet); | |
| 118 } | |
| 119 | |
| 120 bool IsConnectionIdInTimeWait(QuicConnectionId connection_id) { | |
| 121 return time_wait_list_manager_.IsConnectionIdInTimeWait(connection_id); | |
| 122 } | |
| 123 | |
| 124 void ProcessPacket(QuicConnectionId connection_id, | |
| 125 QuicPacketSequenceNumber sequence_number) { | |
| 126 QuicEncryptedPacket packet(nullptr, 0); | |
| 127 time_wait_list_manager_.ProcessPacket(server_address_, | |
| 128 client_address_, | |
| 129 connection_id, | |
| 130 sequence_number, | |
| 131 packet); | |
| 132 } | |
| 133 | |
| 134 QuicEncryptedPacket* ConstructEncryptedPacket( | |
| 135 EncryptionLevel level, | |
| 136 QuicConnectionId connection_id, | |
| 137 QuicPacketSequenceNumber sequence_number) { | |
| 138 QuicPacketHeader header; | |
| 139 header.public_header.connection_id = connection_id; | |
| 140 header.public_header.connection_id_length = PACKET_8BYTE_CONNECTION_ID; | |
| 141 header.public_header.version_flag = false; | |
| 142 header.public_header.reset_flag = false; | |
| 143 header.public_header.sequence_number_length = PACKET_6BYTE_SEQUENCE_NUMBER; | |
| 144 header.packet_sequence_number = sequence_number; | |
| 145 header.entropy_flag = false; | |
| 146 header.entropy_hash = 0; | |
| 147 header.fec_flag = false; | |
| 148 header.is_in_fec_group = NOT_IN_FEC_GROUP; | |
| 149 header.fec_group = 0; | |
| 150 QuicStreamFrame stream_frame(1, false, 0, MakeIOVector("data")); | |
| 151 QuicFrame frame(&stream_frame); | |
| 152 QuicFrames frames; | |
| 153 frames.push_back(frame); | |
| 154 scoped_ptr<QuicPacket> packet( | |
| 155 BuildUnsizedDataPacket(&framer_, header, frames)); | |
| 156 EXPECT_TRUE(packet != nullptr); | |
| 157 QuicEncryptedPacket* encrypted = framer_.EncryptPacket(ENCRYPTION_NONE, | |
| 158 sequence_number, | |
| 159 *packet); | |
| 160 EXPECT_TRUE(encrypted != nullptr); | |
| 161 return encrypted; | |
| 162 } | |
| 163 | |
| 164 NiceMock<MockFakeTimeEpollServer> epoll_server_; | |
| 165 StrictMock<MockPacketWriter> writer_; | |
| 166 StrictMock<MockQuicServerSessionVisitor> visitor_; | |
| 167 QuicTimeWaitListManager time_wait_list_manager_; | |
| 168 QuicFramer framer_; | |
| 169 QuicConnectionId connection_id_; | |
| 170 IPEndPoint server_address_; | |
| 171 IPEndPoint client_address_; | |
| 172 bool writer_is_blocked_; | |
| 173 }; | |
| 174 | |
| 175 class ValidatePublicResetPacketPredicate | |
| 176 : public MatcherInterface<const std::tr1::tuple<const char*, int> > { | |
| 177 public: | |
| 178 explicit ValidatePublicResetPacketPredicate(QuicConnectionId connection_id, | |
| 179 QuicPacketSequenceNumber number) | |
| 180 : connection_id_(connection_id), sequence_number_(number) { | |
| 181 } | |
| 182 | |
| 183 virtual bool MatchAndExplain( | |
| 184 const std::tr1::tuple<const char*, int> packet_buffer, | |
| 185 testing::MatchResultListener* /* listener */) const override { | |
| 186 FramerVisitorCapturingPublicReset visitor; | |
| 187 QuicFramer framer(QuicSupportedVersions(), | |
| 188 QuicTime::Zero(), | |
| 189 false); | |
| 190 framer.set_visitor(&visitor); | |
| 191 QuicEncryptedPacket encrypted(std::tr1::get<0>(packet_buffer), | |
| 192 std::tr1::get<1>(packet_buffer)); | |
| 193 framer.ProcessPacket(encrypted); | |
| 194 QuicPublicResetPacket packet = visitor.public_reset_packet(); | |
| 195 return connection_id_ == packet.public_header.connection_id && | |
| 196 packet.public_header.reset_flag && !packet.public_header.version_flag && | |
| 197 sequence_number_ == packet.rejected_sequence_number && | |
| 198 net::test::TestPeerIPAddress() == packet.client_address.address() && | |
| 199 kTestPort == packet.client_address.port(); | |
| 200 } | |
| 201 | |
| 202 virtual void DescribeTo(::std::ostream* os) const override {} | |
| 203 | |
| 204 virtual void DescribeNegationTo(::std::ostream* os) const override {} | |
| 205 | |
| 206 private: | |
| 207 QuicConnectionId connection_id_; | |
| 208 QuicPacketSequenceNumber sequence_number_; | |
| 209 }; | |
| 210 | |
| 211 | |
| 212 Matcher<const std::tr1::tuple<const char*, int> > PublicResetPacketEq( | |
| 213 QuicConnectionId connection_id, | |
| 214 QuicPacketSequenceNumber sequence_number) { | |
| 215 return MakeMatcher(new ValidatePublicResetPacketPredicate(connection_id, | |
| 216 sequence_number)); | |
| 217 } | |
| 218 | |
| 219 TEST_F(QuicTimeWaitListManagerTest, CheckConnectionIdInTimeWait) { | |
| 220 EXPECT_FALSE(IsConnectionIdInTimeWait(connection_id_)); | |
| 221 EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id_)); | |
| 222 AddConnectionId(connection_id_); | |
| 223 EXPECT_EQ(1u, time_wait_list_manager_.num_connections()); | |
| 224 EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_)); | |
| 225 } | |
| 226 | |
| 227 TEST_F(QuicTimeWaitListManagerTest, SendConnectionClose) { | |
| 228 size_t kConnectionCloseLength = 100; | |
| 229 EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id_)); | |
| 230 AddConnectionId( | |
| 231 connection_id_, | |
| 232 QuicVersionMax(), | |
| 233 new QuicEncryptedPacket( | |
| 234 new char[kConnectionCloseLength], kConnectionCloseLength, true)); | |
| 235 const int kRandomSequenceNumber = 1; | |
| 236 EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength, | |
| 237 server_address_.address(), | |
| 238 client_address_)) | |
| 239 .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1))); | |
| 240 | |
| 241 ProcessPacket(connection_id_, kRandomSequenceNumber); | |
| 242 } | |
| 243 | |
| 244 TEST_F(QuicTimeWaitListManagerTest, SendPublicReset) { | |
| 245 EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id_)); | |
| 246 AddConnectionId(connection_id_); | |
| 247 const int kRandomSequenceNumber = 1; | |
| 248 EXPECT_CALL(writer_, WritePacket(_, _, | |
| 249 server_address_.address(), | |
| 250 client_address_)) | |
| 251 .With(Args<0, 1>(PublicResetPacketEq(connection_id_, | |
| 252 kRandomSequenceNumber))) | |
| 253 .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0))); | |
| 254 | |
| 255 ProcessPacket(connection_id_, kRandomSequenceNumber); | |
| 256 } | |
| 257 | |
| 258 TEST_F(QuicTimeWaitListManagerTest, SendPublicResetWithExponentialBackOff) { | |
| 259 EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id_)); | |
| 260 AddConnectionId(connection_id_); | |
| 261 EXPECT_EQ(1u, time_wait_list_manager_.num_connections()); | |
| 262 for (int sequence_number = 1; sequence_number < 101; ++sequence_number) { | |
| 263 if ((sequence_number & (sequence_number - 1)) == 0) { | |
| 264 EXPECT_CALL(writer_, WritePacket(_, _, _, _)) | |
| 265 .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1))); | |
| 266 } | |
| 267 ProcessPacket(connection_id_, sequence_number); | |
| 268 // Send public reset with exponential back off. | |
| 269 if ((sequence_number & (sequence_number - 1)) == 0) { | |
| 270 EXPECT_TRUE(QuicTimeWaitListManagerPeer::ShouldSendResponse( | |
| 271 &time_wait_list_manager_, sequence_number)); | |
| 272 } else { | |
| 273 EXPECT_FALSE(QuicTimeWaitListManagerPeer::ShouldSendResponse( | |
| 274 &time_wait_list_manager_, sequence_number)); | |
| 275 } | |
| 276 } | |
| 277 } | |
| 278 | |
| 279 TEST_F(QuicTimeWaitListManagerTest, CleanUpOldConnectionIds) { | |
| 280 const size_t kConnectionIdCount = 100; | |
| 281 const size_t kOldConnectionIdCount = 31; | |
| 282 | |
| 283 // Add connection_ids such that their expiry time is kTimeWaitPeriod_. | |
| 284 epoll_server_.set_now_in_usec(0); | |
| 285 for (size_t connection_id = 1; connection_id <= kOldConnectionIdCount; | |
| 286 ++connection_id) { | |
| 287 EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id)); | |
| 288 AddConnectionId(connection_id); | |
| 289 } | |
| 290 EXPECT_EQ(kOldConnectionIdCount, time_wait_list_manager_.num_connections()); | |
| 291 | |
| 292 // Add remaining connection_ids such that their add time is | |
| 293 // 2 * kTimeWaitPeriod. | |
| 294 const QuicTime::Delta time_wait_period = | |
| 295 QuicTimeWaitListManagerPeer::time_wait_period(&time_wait_list_manager_); | |
| 296 epoll_server_.set_now_in_usec(time_wait_period.ToMicroseconds()); | |
| 297 for (size_t connection_id = kOldConnectionIdCount + 1; | |
| 298 connection_id <= kConnectionIdCount; ++connection_id) { | |
| 299 EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id)); | |
| 300 AddConnectionId(connection_id); | |
| 301 } | |
| 302 EXPECT_EQ(kConnectionIdCount, time_wait_list_manager_.num_connections()); | |
| 303 | |
| 304 QuicTime::Delta offset = QuicTime::Delta::FromMicroseconds(39); | |
| 305 // Now set the current time as time_wait_period + offset usecs. | |
| 306 epoll_server_.set_now_in_usec(time_wait_period.Add(offset).ToMicroseconds()); | |
| 307 // After all the old connection_ids are cleaned up, check the next alarm | |
| 308 // interval. | |
| 309 int64 next_alarm_time = epoll_server_.ApproximateNowInUsec() + | |
| 310 time_wait_period.Subtract(offset).ToMicroseconds(); | |
| 311 EXPECT_CALL(epoll_server_, RegisterAlarm(next_alarm_time, _)); | |
| 312 | |
| 313 for (size_t connection_id = 1; connection_id <= kConnectionIdCount; | |
| 314 ++connection_id) { | |
| 315 if (connection_id <= kOldConnectionIdCount) { | |
| 316 EXPECT_CALL(visitor_, OnConnectionRemovedFromTimeWaitList(connection_id)); | |
| 317 } | |
| 318 } | |
| 319 time_wait_list_manager_.CleanUpOldConnectionIds(); | |
| 320 for (size_t connection_id = 1; connection_id <= kConnectionIdCount; | |
| 321 ++connection_id) { | |
| 322 EXPECT_EQ(connection_id > kOldConnectionIdCount, | |
| 323 IsConnectionIdInTimeWait(connection_id)) | |
| 324 << "kOldConnectionIdCount: " << kOldConnectionIdCount | |
| 325 << " connection_id: " << connection_id; | |
| 326 } | |
| 327 EXPECT_EQ(kConnectionIdCount - kOldConnectionIdCount, | |
| 328 time_wait_list_manager_.num_connections()); | |
| 329 } | |
| 330 | |
| 331 TEST_F(QuicTimeWaitListManagerTest, SendQueuedPackets) { | |
| 332 QuicConnectionId connection_id = 1; | |
| 333 EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id)); | |
| 334 AddConnectionId(connection_id); | |
| 335 QuicPacketSequenceNumber sequence_number = 234; | |
| 336 scoped_ptr<QuicEncryptedPacket> packet(ConstructEncryptedPacket( | |
| 337 ENCRYPTION_NONE, connection_id, sequence_number)); | |
| 338 // Let first write through. | |
| 339 EXPECT_CALL(writer_, WritePacket(_, _, | |
| 340 server_address_.address(), | |
| 341 client_address_)) | |
| 342 .With(Args<0, 1>(PublicResetPacketEq(connection_id, | |
| 343 sequence_number))) | |
| 344 .WillOnce(Return(WriteResult(WRITE_STATUS_OK, packet->length()))); | |
| 345 ProcessPacket(connection_id, sequence_number); | |
| 346 | |
| 347 // write block for the next packet. | |
| 348 EXPECT_CALL(writer_, WritePacket(_, _, | |
| 349 server_address_.address(), | |
| 350 client_address_)) | |
| 351 .With(Args<0, 1>(PublicResetPacketEq(connection_id, | |
| 352 sequence_number))) | |
| 353 .WillOnce(DoAll( | |
| 354 Assign(&writer_is_blocked_, true), | |
| 355 Return(WriteResult(WRITE_STATUS_BLOCKED, EAGAIN)))); | |
| 356 EXPECT_CALL(visitor_, OnWriteBlocked(&time_wait_list_manager_)); | |
| 357 ProcessPacket(connection_id, sequence_number); | |
| 358 // 3rd packet. No public reset should be sent; | |
| 359 ProcessPacket(connection_id, sequence_number); | |
| 360 | |
| 361 // write packet should not be called since we are write blocked but the | |
| 362 // should be queued. | |
| 363 QuicConnectionId other_connection_id = 2; | |
| 364 EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(other_connection_id)); | |
| 365 AddConnectionId(other_connection_id); | |
| 366 QuicPacketSequenceNumber other_sequence_number = 23423; | |
| 367 scoped_ptr<QuicEncryptedPacket> other_packet( | |
| 368 ConstructEncryptedPacket( | |
| 369 ENCRYPTION_NONE, other_connection_id, other_sequence_number)); | |
| 370 EXPECT_CALL(writer_, WritePacket(_, _, _, _)) | |
| 371 .Times(0); | |
| 372 EXPECT_CALL(visitor_, OnWriteBlocked(&time_wait_list_manager_)); | |
| 373 ProcessPacket(other_connection_id, other_sequence_number); | |
| 374 EXPECT_EQ(2u, time_wait_list_manager_.num_connections()); | |
| 375 | |
| 376 // Now expect all the write blocked public reset packets to be sent again. | |
| 377 writer_is_blocked_ = false; | |
| 378 EXPECT_CALL(writer_, WritePacket(_, _, | |
| 379 server_address_.address(), | |
| 380 client_address_)) | |
| 381 .With(Args<0, 1>(PublicResetPacketEq(connection_id, | |
| 382 sequence_number))) | |
| 383 .WillOnce(Return(WriteResult(WRITE_STATUS_OK, packet->length()))); | |
| 384 EXPECT_CALL(writer_, WritePacket(_, _, | |
| 385 server_address_.address(), | |
| 386 client_address_)) | |
| 387 .With(Args<0, 1>(PublicResetPacketEq(other_connection_id, | |
| 388 other_sequence_number))) | |
| 389 .WillOnce(Return(WriteResult(WRITE_STATUS_OK, | |
| 390 other_packet->length()))); | |
| 391 time_wait_list_manager_.OnCanWrite(); | |
| 392 } | |
| 393 | |
| 394 TEST_F(QuicTimeWaitListManagerTest, GetQuicVersionFromMap) { | |
| 395 const int kConnectionId1 = 123; | |
| 396 const int kConnectionId2 = 456; | |
| 397 const int kConnectionId3 = 789; | |
| 398 | |
| 399 EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(kConnectionId1)); | |
| 400 EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(kConnectionId2)); | |
| 401 EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(kConnectionId3)); | |
| 402 AddConnectionId(kConnectionId1, QuicVersionMin(), nullptr); | |
| 403 AddConnectionId(kConnectionId2, QuicVersionMax(), nullptr); | |
| 404 AddConnectionId(kConnectionId3, QuicVersionMax(), nullptr); | |
| 405 | |
| 406 EXPECT_EQ(QuicVersionMin(), | |
| 407 QuicTimeWaitListManagerPeer::GetQuicVersionFromConnectionId( | |
| 408 &time_wait_list_manager_, kConnectionId1)); | |
| 409 EXPECT_EQ(QuicVersionMax(), | |
| 410 QuicTimeWaitListManagerPeer::GetQuicVersionFromConnectionId( | |
| 411 &time_wait_list_manager_, kConnectionId2)); | |
| 412 EXPECT_EQ(QuicVersionMax(), | |
| 413 QuicTimeWaitListManagerPeer::GetQuicVersionFromConnectionId( | |
| 414 &time_wait_list_manager_, kConnectionId3)); | |
| 415 } | |
| 416 | |
| 417 TEST_F(QuicTimeWaitListManagerTest, AddConnectionIdTwice) { | |
| 418 // Add connection_ids such that their expiry time is kTimeWaitPeriod_. | |
| 419 epoll_server_.set_now_in_usec(0); | |
| 420 EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id_)); | |
| 421 AddConnectionId(connection_id_); | |
| 422 EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_)); | |
| 423 size_t kConnectionCloseLength = 100; | |
| 424 AddConnectionId( | |
| 425 connection_id_, | |
| 426 QuicVersionMax(), | |
| 427 new QuicEncryptedPacket( | |
| 428 new char[kConnectionCloseLength], kConnectionCloseLength, true)); | |
| 429 EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_)); | |
| 430 EXPECT_EQ(1u, time_wait_list_manager_.num_connections()); | |
| 431 | |
| 432 EXPECT_CALL(writer_, WritePacket(_, | |
| 433 kConnectionCloseLength, | |
| 434 server_address_.address(), | |
| 435 client_address_)) | |
| 436 .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1))); | |
| 437 | |
| 438 const int kRandomSequenceNumber = 1; | |
| 439 ProcessPacket(connection_id_, kRandomSequenceNumber); | |
| 440 | |
| 441 const QuicTime::Delta time_wait_period = | |
| 442 QuicTimeWaitListManagerPeer::time_wait_period(&time_wait_list_manager_); | |
| 443 | |
| 444 QuicTime::Delta offset = QuicTime::Delta::FromMicroseconds(39); | |
| 445 // Now set the current time as time_wait_period + offset usecs. | |
| 446 epoll_server_.set_now_in_usec(time_wait_period.Add(offset).ToMicroseconds()); | |
| 447 // After the connection_ids are cleaned up, check the next alarm interval. | |
| 448 int64 next_alarm_time = epoll_server_.ApproximateNowInUsec() + | |
| 449 time_wait_period.ToMicroseconds(); | |
| 450 | |
| 451 EXPECT_CALL(epoll_server_, RegisterAlarm(next_alarm_time, _)); | |
| 452 EXPECT_CALL(visitor_, OnConnectionRemovedFromTimeWaitList(connection_id_)); | |
| 453 time_wait_list_manager_.CleanUpOldConnectionIds(); | |
| 454 EXPECT_FALSE(IsConnectionIdInTimeWait(connection_id_)); | |
| 455 EXPECT_EQ(0u, time_wait_list_manager_.num_connections()); | |
| 456 } | |
| 457 | |
| 458 TEST_F(QuicTimeWaitListManagerTest, ConnectionIdsOrderedByTime) { | |
| 459 // Simple randomization: the values of connection_ids are swapped based on the | |
| 460 // current seconds on the clock. If the container is broken, the test will be | |
| 461 // 50% flaky. | |
| 462 int odd_second = static_cast<int>(epoll_server_.ApproximateNowInUsec()) % 2; | |
| 463 EXPECT_TRUE(odd_second == 0 || odd_second == 1); | |
| 464 const QuicConnectionId kConnectionId1 = odd_second; | |
| 465 const QuicConnectionId kConnectionId2 = 1 - odd_second; | |
| 466 | |
| 467 // 1 will hash lower than 2, but we add it later. They should come out in the | |
| 468 // add order, not hash order. | |
| 469 epoll_server_.set_now_in_usec(0); | |
| 470 EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(kConnectionId1)); | |
| 471 AddConnectionId(kConnectionId1); | |
| 472 epoll_server_.set_now_in_usec(10); | |
| 473 EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(kConnectionId2)); | |
| 474 AddConnectionId(kConnectionId2); | |
| 475 EXPECT_EQ(2u, time_wait_list_manager_.num_connections()); | |
| 476 | |
| 477 const QuicTime::Delta time_wait_period = | |
| 478 QuicTimeWaitListManagerPeer::time_wait_period(&time_wait_list_manager_); | |
| 479 epoll_server_.set_now_in_usec(time_wait_period.ToMicroseconds() + 1); | |
| 480 | |
| 481 EXPECT_CALL(epoll_server_, RegisterAlarm(_, _)); | |
| 482 | |
| 483 EXPECT_CALL(visitor_, OnConnectionRemovedFromTimeWaitList(kConnectionId1)); | |
| 484 time_wait_list_manager_.CleanUpOldConnectionIds(); | |
| 485 EXPECT_FALSE(IsConnectionIdInTimeWait(kConnectionId1)); | |
| 486 EXPECT_TRUE(IsConnectionIdInTimeWait(kConnectionId2)); | |
| 487 EXPECT_EQ(1u, time_wait_list_manager_.num_connections()); | |
| 488 } | |
| 489 | |
| 490 TEST_F(QuicTimeWaitListManagerTest, MaxConnectionsTest) { | |
| 491 ValueRestore<bool> old_flag(&FLAGS_quic_limit_time_wait_list_size, true); | |
| 492 // Basically, shut off time-based eviction. | |
| 493 FLAGS_quic_time_wait_list_seconds = 10000000000; | |
| 494 FLAGS_quic_time_wait_list_max_connections = 5; | |
| 495 | |
| 496 QuicConnectionId current_connection_id = 0; | |
| 497 // Add exactly the maximum number of connections | |
| 498 for (int64 i = 0; i < FLAGS_quic_time_wait_list_max_connections; ++i) { | |
| 499 ++current_connection_id; | |
| 500 EXPECT_FALSE(IsConnectionIdInTimeWait(current_connection_id)); | |
| 501 EXPECT_CALL(visitor_, | |
| 502 OnConnectionAddedToTimeWaitList(current_connection_id)); | |
| 503 AddConnectionId(current_connection_id); | |
| 504 EXPECT_EQ(current_connection_id, time_wait_list_manager_.num_connections()); | |
| 505 EXPECT_TRUE(IsConnectionIdInTimeWait(current_connection_id)); | |
| 506 } | |
| 507 | |
| 508 // Now keep adding. Since we're already at the max, every new connection-id | |
| 509 // will evict the oldest one. | |
| 510 for (int64 i = 0; i < FLAGS_quic_time_wait_list_max_connections; ++i) { | |
| 511 ++current_connection_id; | |
| 512 const QuicConnectionId id_to_evict = | |
| 513 current_connection_id - FLAGS_quic_time_wait_list_max_connections; | |
| 514 EXPECT_TRUE(IsConnectionIdInTimeWait(id_to_evict)); | |
| 515 EXPECT_FALSE(IsConnectionIdInTimeWait(current_connection_id)); | |
| 516 EXPECT_CALL(visitor_, OnConnectionRemovedFromTimeWaitList(id_to_evict)); | |
| 517 EXPECT_CALL(visitor_, | |
| 518 OnConnectionAddedToTimeWaitList(current_connection_id)); | |
| 519 AddConnectionId(current_connection_id); | |
| 520 EXPECT_EQ(static_cast<size_t>(FLAGS_quic_time_wait_list_max_connections), | |
| 521 time_wait_list_manager_.num_connections()); | |
| 522 EXPECT_FALSE(IsConnectionIdInTimeWait(id_to_evict)); | |
| 523 EXPECT_TRUE(IsConnectionIdInTimeWait(current_connection_id)); | |
| 524 } | |
| 525 } | |
| 526 | |
| 527 } // namespace | |
| 528 } // namespace test | |
| 529 } // namespace tools | |
| 530 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master