lib/mvfst
1
0
Fork 0
mirror of https://github.com/facebookincubator/mvfst.git synced 2025-08-06 22:22:38 +03:00
Code Activity

Add vantage point to qlog.

Browse Source 
Summary: Landing an outstanding diff

Reviewed By: yangchi

Differential Revision: D19261395

fbshipit-source-id: 437461222ff04f5c3271567d3bb064bceaf80029
This commit is contained in:
Mirko Andjic
2020-01-07 11:17:41 -08:00
committed by Facebook Github Bot
parent c610a8c512
commit 3f419b2eb2
24 changed files with 141 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
quic/QuicConstants.cpp
View File

@@ -116,4 +116,5 @@ folly::StringPiece writeNoWriteReasonString(NoWriteReason reason) {
} }
folly::assume_unreachable(); folly::assume_unreachable();
} }
} // namespace quic } // namespace quic

1
quic/api/QuicTransportBase.h
View File

@@ -11,6 +11,7 @@
#include <folly/ExceptionWrapper.h> #include <folly/ExceptionWrapper.h>
#include <folly/io/async/AsyncUDPSocket.h> #include <folly/io/async/AsyncUDPSocket.h>
#include <folly/io/async/HHWheelTimer.h> #include <folly/io/async/HHWheelTimer.h>
#include <quic/QuicConstants.h>
#include <quic/QuicException.h> #include <quic/QuicException.h>
#include <quic/api/QuicSocket.h> #include <quic/api/QuicSocket.h>
#include <quic/common/FunctionLooper.h> #include <quic/common/FunctionLooper.h>

2
quic/api/test/QuicTransportBaseTest.cpp
View File

@@ -1039,7 +1039,7 @@ TEST_F(QuicTransportImplTest, LossTimeoutNoLessThanTickInterval) {
} }
TEST_F(QuicTransportImplTest, CloseStreamAfterReadError) { TEST_F(QuicTransportImplTest, CloseStreamAfterReadError) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
transport->transportConn->qLogger = qLogger; transport->transportConn->qLogger = qLogger;
auto stream1 = transport->createBidirectionalStream().value(); auto stream1 = transport->createBidirectionalStream().value();

28
quic/api/test/QuicTransportFunctionsTest.cpp
View File

@@ -182,7 +182,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnection) {
auto mockCongestionController = std::make_unique<MockCongestionController>(); auto mockCongestionController = std::make_unique<MockCongestionController>();
auto rawCongestionController = mockCongestionController.get(); auto rawCongestionController = mockCongestionController.get();
conn->congestionController = std::move(mockCongestionController); conn->congestionController = std::move(mockCongestionController);
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT); conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
// Builds a fake packet to test with. // Builds a fake packet to test with.
auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake); auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
@@ -343,7 +343,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnection) {
TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionPacketSorting) { TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionPacketSorting) {
auto conn = createConn(); auto conn = createConn();
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT); conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
conn->ackStates.initialAckState.nextPacketNum = 0; conn->ackStates.initialAckState.nextPacketNum = 0;
conn->ackStates.handshakeAckState.nextPacketNum = 1; conn->ackStates.handshakeAckState.nextPacketNum = 1;
conn->ackStates.appDataAckState.nextPacketNum = 2; conn->ackStates.appDataAckState.nextPacketNum = 2;
@@ -417,7 +417,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionPacketSorting) {
TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionFinOnly) { TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionFinOnly) {
auto conn = createConn(); auto conn = createConn();
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT); conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake); auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
auto stream1 = conn->streamManager->createNextBidirectionalStream().value(); auto stream1 = conn->streamManager->createNextBidirectionalStream().value();
@@ -458,7 +458,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionFinOnly) {
TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionAllBytesExceptFin) { TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionAllBytesExceptFin) {
auto conn = createConn(); auto conn = createConn();
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT); conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake); auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
auto stream1 = conn->streamManager->createNextUnidirectionalStream().value(); auto stream1 = conn->streamManager->createNextUnidirectionalStream().value();
@@ -505,7 +505,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionAllBytesExceptFin) {
TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionEmptyAckWriteResult) { TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionEmptyAckWriteResult) {
auto conn = createConn(); auto conn = createConn();
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT); conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake); auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
// None of the largestAckScheduled should be changed. But since // None of the largestAckScheduled should be changed. But since
// buildEmptyPacket() builds a Handshake packet, we use handshakeAckState to // buildEmptyPacket() builds a Handshake packet, we use handshakeAckState to
@@ -534,7 +534,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionEmptyAckWriteResult) {
TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionPureAckCounter) { TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionPureAckCounter) {
auto conn = createConn(); auto conn = createConn();
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT); conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
auto stream = conn->streamManager->createNextBidirectionalStream().value(); auto stream = conn->streamManager->createNextBidirectionalStream().value();
writeDataToQuicStream(*stream, nullptr, true); writeDataToQuicStream(*stream, nullptr, true);
EXPECT_EQ(0, conn->outstandingHandshakePacketsCount); EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
@@ -584,7 +584,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionPureAckCounter) {
TEST_F(QuicTransportFunctionsTest, TestPaddingPureAckPacketIsStillPureAck) { TEST_F(QuicTransportFunctionsTest, TestPaddingPureAckPacketIsStillPureAck) {
auto conn = createConn(); auto conn = createConn();
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT); conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake); auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
auto packetEncodedSize = auto packetEncodedSize =
packet.header ? packet.header->computeChainDataLength() : 0; packet.header ? packet.header->computeChainDataLength() : 0;
@@ -614,7 +614,7 @@ TEST_F(QuicTransportFunctionsTest, TestPaddingPureAckPacketIsStillPureAck) {
TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionHandshakeCounter) { TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionHandshakeCounter) {
auto conn = createConn(); auto conn = createConn();
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT); conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
auto stream = conn->streamManager->createNextBidirectionalStream().value(); auto stream = conn->streamManager->createNextBidirectionalStream().value();
writeDataToQuicStream(*stream, nullptr, true); writeDataToQuicStream(*stream, nullptr, true);
EXPECT_EQ(0, conn->outstandingHandshakePacketsCount); EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
@@ -681,7 +681,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionHandshakeCounter) {
TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionForOneRttCryptoData) { TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionForOneRttCryptoData) {
auto conn = createConn(); auto conn = createConn();
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT); conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
auto stream = conn->streamManager->createNextBidirectionalStream().value(); auto stream = conn->streamManager->createNextBidirectionalStream().value();
writeDataToQuicStream(*stream, nullptr, true); writeDataToQuicStream(*stream, nullptr, true);
EXPECT_EQ(0, conn->outstandingHandshakePacketsCount); EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
@@ -752,7 +752,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionForOneRttCryptoData) {
TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithPureAck) { TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithPureAck) {
auto conn = createConn(); auto conn = createConn();
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT); conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake); auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
auto mockPacer = std::make_unique<MockPacer>(); auto mockPacer = std::make_unique<MockPacer>();
auto rawPacer = mockPacer.get(); auto rawPacer = mockPacer.get();
@@ -789,7 +789,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithPureAck) {
TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithBytesStats) { TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithBytesStats) {
auto conn = createConn(); auto conn = createConn();
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT); conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
auto stream = conn->streamManager->createNextBidirectionalStream().value(); auto stream = conn->streamManager->createNextBidirectionalStream().value();
auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake); auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
// This is clearly not 555 bytes. I just need some data inside the packet. // This is clearly not 555 bytes. I just need some data inside the packet.
@@ -845,7 +845,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithBytesStats) {
TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithCloneResult) { TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithCloneResult) {
auto conn = createConn(); auto conn = createConn();
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT); conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
auto mockCongestionController = std::make_unique<MockCongestionController>(); auto mockCongestionController = std::make_unique<MockCongestionController>();
auto rawCongestionController = mockCongestionController.get(); auto rawCongestionController = mockCongestionController.get();
conn->congestionController = std::move(mockCongestionController); conn->congestionController = std::move(mockCongestionController);
@@ -900,7 +900,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithCloneResult) {
TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionStreamWindowUpdate) { TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionStreamWindowUpdate) {
auto conn = createConn(); auto conn = createConn();
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT); conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake); auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
auto packetNum = packet.packet.header.getPacketSequenceNum(); auto packetNum = packet.packet.header.getPacketSequenceNum();
auto stream = conn->streamManager->createNextBidirectionalStream().value(); auto stream = conn->streamManager->createNextBidirectionalStream().value();
@@ -935,7 +935,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionStreamWindowUpdate) {
TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionConnWindowUpdate) { TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionConnWindowUpdate) {
auto conn = createConn(); auto conn = createConn();
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT); conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake); auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
auto packetNum = packet.packet.header.getPacketSequenceNum(); auto packetNum = packet.packet.header.getPacketSequenceNum();
conn->pendingEvents.connWindowUpdate = true; conn->pendingEvents.connWindowUpdate = true;

2
quic/api/test/QuicTransportTest.cpp
View File

@@ -575,7 +575,7 @@ TEST_F(QuicTransportTest, WriteMultipleStreams) {
TEST_F(QuicTransportTest, WriteFlowControl) { TEST_F(QuicTransportTest, WriteFlowControl) {
auto& conn = transport_->getConnectionState(); auto& conn = transport_->getConnectionState();
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
conn.qLogger = qLogger; conn.qLogger = qLogger;
auto streamId = transport_->createBidirectionalStream().value(); auto streamId = transport_->createBidirectionalStream().value();

38
quic/client/test/QuicClientTransportTest.cpp
View File

@@ -465,7 +465,7 @@ TEST_P(QuicClientTransportIntegrationTest, TLSAlert) {
verifier = nullptr; verifier = nullptr;
client = createClient(); client = createClient();
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
client->getNonConstConn().qLogger = qLogger; client->getNonConstConn().qLogger = qLogger;
EXPECT_CALL(clientConnCallback, onConnectionError(_)) EXPECT_CALL(clientConnCallback, onConnectionError(_))
.WillOnce(Invoke([&](const auto& errorCode) { .WillOnce(Invoke([&](const auto& errorCode) {
@@ -486,7 +486,7 @@ TEST_P(QuicClientTransportIntegrationTest, TLSAlert) {
} }
TEST_P(QuicClientTransportIntegrationTest, BadServerTest) { TEST_P(QuicClientTransportIntegrationTest, BadServerTest) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
client->getNonConstConn().qLogger = qLogger; client->getNonConstConn().qLogger = qLogger;
// Point the client to a bad server. // Point the client to a bad server.
client->addNewPeerAddress(SocketAddress("127.0.0.1", 14114)); client->addNewPeerAddress(SocketAddress("127.0.0.1", 14114));
@@ -503,7 +503,7 @@ TEST_P(QuicClientTransportIntegrationTest, BadServerTest) {
TEST_P(QuicClientTransportIntegrationTest, NetworkTestConnected) { TEST_P(QuicClientTransportIntegrationTest, NetworkTestConnected) {
expectTransportCallbacks(); expectTransportCallbacks();
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
client->getNonConstConn().qLogger = qLogger; client->getNonConstConn().qLogger = qLogger;
TransportSettings settings; TransportSettings settings;
settings.connectUDP = true; settings.connectUDP = true;
@@ -525,7 +525,7 @@ TEST_P(QuicClientTransportIntegrationTest, NetworkTestConnected) {
TEST_P(QuicClientTransportIntegrationTest, SetTransportSettingsAfterStart) { TEST_P(QuicClientTransportIntegrationTest, SetTransportSettingsAfterStart) {
expectTransportCallbacks(); expectTransportCallbacks();
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
client->getNonConstConn().qLogger = qLogger; client->getNonConstConn().qLogger = qLogger;
TransportSettings settings; TransportSettings settings;
settings.connectUDP = true; settings.connectUDP = true;
@@ -600,7 +600,7 @@ TEST_P(QuicClientTransportIntegrationTest, TestZeroRttSuccess) {
TEST_P(QuicClientTransportIntegrationTest, TestZeroRttRejection) { TEST_P(QuicClientTransportIntegrationTest, TestZeroRttRejection) {
expectTransportCallbacks(); expectTransportCallbacks();
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
client->getNonConstConn().qLogger = qLogger; client->getNonConstConn().qLogger = qLogger;
auto cachedPsk = setupZeroRttOnClientCtx(*clientCtx, hostname, getVersion()); auto cachedPsk = setupZeroRttOnClientCtx(*clientCtx, hostname, getVersion());
pskCache_->putPsk(hostname, cachedPsk); pskCache_->putPsk(hostname, cachedPsk);
@@ -1739,7 +1739,7 @@ TEST_F(QuicClientTransportTest, AddNewPeerAddressSetsPacketSize) {
TEST_F(QuicClientTransportTest, onNetworkSwitchNoReplace) { TEST_F(QuicClientTransportTest, onNetworkSwitchNoReplace) {
client->getNonConstConn().oneRttWriteCipher = test::createNoOpAead(); client->getNonConstConn().oneRttWriteCipher = test::createNoOpAead();
auto mockQLogger = std::make_shared<MockQLogger>(); auto mockQLogger = std::make_shared<MockQLogger>(VantagePoint::Client);
client->setQLogger(mockQLogger); client->setQLogger(mockQLogger);
EXPECT_CALL(*mockQLogger, addConnectionMigrationUpdate(true)).Times(0); EXPECT_CALL(*mockQLogger, addConnectionMigrationUpdate(true)).Times(0);
@@ -1749,7 +1749,7 @@ TEST_F(QuicClientTransportTest, onNetworkSwitchNoReplace) {
TEST_F(QuicClientTransportTest, onNetworkSwitchReplaceAfterHandshake) { TEST_F(QuicClientTransportTest, onNetworkSwitchReplaceAfterHandshake) {
client->getNonConstConn().oneRttWriteCipher = test::createNoOpAead(); client->getNonConstConn().oneRttWriteCipher = test::createNoOpAead();
auto mockQLogger = std::make_shared<MockQLogger>(); auto mockQLogger = std::make_shared<MockQLogger>(VantagePoint::Client);
client->setQLogger(mockQLogger); client->setQLogger(mockQLogger);
auto newSocket = auto newSocket =
@@ -1771,7 +1771,7 @@ TEST_F(QuicClientTransportTest, onNetworkSwitchReplaceNoHandshake) {
auto newSocket = auto newSocket =
std::make_unique<folly::test::MockAsyncUDPSocket>(eventbase_.get()); std::make_unique<folly::test::MockAsyncUDPSocket>(eventbase_.get());
auto newSocketPtr = newSocket.get(); auto newSocketPtr = newSocket.get();
auto mockQLogger = std::make_shared<MockQLogger>(); auto mockQLogger = std::make_shared<MockQLogger>(VantagePoint::Client);
EXPECT_CALL(*mockQLogger, addConnectionMigrationUpdate(true)).Times(0); EXPECT_CALL(*mockQLogger, addConnectionMigrationUpdate(true)).Times(0);
EXPECT_CALL(*newSocketPtr, bind(_)).Times(0); EXPECT_CALL(*newSocketPtr, bind(_)).Times(0);
client->onNetworkSwitch(std::move(newSocket)); client->onNetworkSwitch(std::move(newSocket));
@@ -1862,7 +1862,7 @@ TEST_F(
NetworkUnreachableIsFatalIfContinueAfterDeadline) { NetworkUnreachableIsFatalIfContinueAfterDeadline) {
TransportSettings settings; TransportSettings settings;
settings.continueOnNetworkUnreachable = true; settings.continueOnNetworkUnreachable = true;
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
client->getNonConstConn().qLogger = qLogger; client->getNonConstConn().qLogger = qLogger;
client->setTransportSettings(settings); client->setTransportSettings(settings);
@@ -1963,7 +1963,7 @@ TEST_F(QuicClientTransportTest, IdleTimerResetOnWritingFirstData) {
TEST_F(QuicClientTransportTest, SetQLoggerDcid) { TEST_F(QuicClientTransportTest, SetQLoggerDcid) {
client->setQLogger(nullptr); client->setQLogger(nullptr);
auto mockQLogger = std::make_shared<MockQLogger>(); auto mockQLogger = std::make_shared<MockQLogger>(VantagePoint::Client);
client->setQLogger(mockQLogger); client->setQLogger(mockQLogger);
EXPECT_EQ(client->getConn().clientConnectionId, mockQLogger->dcid); EXPECT_EQ(client->getConn().clientConnectionId, mockQLogger->dcid);
client->closeNow(folly::none); client->closeNow(folly::none);
@@ -2941,7 +2941,7 @@ TEST_P(QuicClientTransportAfterStartTest, ReadStreamCoalesced) {
setConnectionIds(); setConnectionIds();
StreamId streamId = client->createBidirectionalStream().value(); StreamId streamId = client->createBidirectionalStream().value();
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
client->getNonConstConn().qLogger = qLogger; client->getNonConstConn().qLogger = qLogger;
client->setReadCallback(streamId, &readCb); client->setReadCallback(streamId, &readCb);
@@ -3120,7 +3120,7 @@ bool verifyFramePresent(
TEST_F(QuicClientTransportAfterStartTest, CloseConnectionWithStreamPending) { TEST_F(QuicClientTransportAfterStartTest, CloseConnectionWithStreamPending) {
StreamId streamId = client->createBidirectionalStream().value(); StreamId streamId = client->createBidirectionalStream().value();
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
client->getNonConstConn().qLogger = qLogger; client->getNonConstConn().qLogger = qLogger;
auto expected = IOBuf::copyBuffer("hello"); auto expected = IOBuf::copyBuffer("hello");
client->setReadCallback(streamId, &readCb); client->setReadCallback(streamId, &readCb);
@@ -3255,7 +3255,7 @@ TEST_P(
QuicClientTransportAfterStartTestClose, QuicClientTransportAfterStartTestClose,
CloseConnectionWithErrorCleartext) { CloseConnectionWithErrorCleartext) {
StreamId streamId = client->createBidirectionalStream().value(); StreamId streamId = client->createBidirectionalStream().value();
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
client->getNonConstConn().qLogger = qLogger; client->getNonConstConn().qLogger = qLogger;
auto expected = IOBuf::copyBuffer("hello"); auto expected = IOBuf::copyBuffer("hello");
client->setReadCallback(streamId, &readCb); client->setReadCallback(streamId, &readCb);
@@ -3540,7 +3540,7 @@ TEST_F(QuicClientTransportAfterStartTest, IdleTimerNotResetOnDuplicatePacket) {
} }
TEST_P(QuicClientTransportAfterStartTestClose, TimeoutsNotSetAfterClose) { TEST_P(QuicClientTransportAfterStartTestClose, TimeoutsNotSetAfterClose) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
client->getNonConstConn().qLogger = qLogger; client->getNonConstConn().qLogger = qLogger;
StreamId streamId = client->createBidirectionalStream().value(); StreamId streamId = client->createBidirectionalStream().value();
@@ -3640,7 +3640,7 @@ TEST_F(QuicClientTransportAfterStartTest, IdleTimeoutExpired) {
} }
TEST_F(QuicClientTransportAfterStartTest, RecvDataAfterIdleTimeout) { TEST_F(QuicClientTransportAfterStartTest, RecvDataAfterIdleTimeout) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
client->getNonConstConn().qLogger = qLogger; client->getNonConstConn().qLogger = qLogger;
EXPECT_CALL(*sock, close()); EXPECT_CALL(*sock, close());
client->idleTimeout().timeoutExpired(); client->idleTimeout().timeoutExpired();
@@ -4070,7 +4070,7 @@ TEST_F(QuicClientTransportAfterStartTest, BadStatelessResetWontCloseTransport) {
TEST_F(QuicClientTransportVersionAndRetryTest, RetryPacket) { TEST_F(QuicClientTransportVersionAndRetryTest, RetryPacket) {
// Create a stream and attempt to send some data to the server // Create a stream and attempt to send some data to the server
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
client->getNonConstConn().qLogger = qLogger; client->getNonConstConn().qLogger = qLogger;
StreamId streamId = *client->createBidirectionalStream(); StreamId streamId = *client->createBidirectionalStream();
@@ -4582,7 +4582,7 @@ TEST_F(QuicClientTransportAfterStartTest, ReceiveConnectionClose) {
} }
TEST_F(QuicClientTransportAfterStartTest, ReceiveApplicationClose) { TEST_F(QuicClientTransportAfterStartTest, ReceiveApplicationClose) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
client->getNonConstConn().qLogger = qLogger; client->getNonConstConn().qLogger = qLogger;
ShortHeader header( ShortHeader header(
@@ -5279,7 +5279,7 @@ INSTANTIATE_TEST_CASE_P(
::Values(0, 8)); ::Values(0, 8));
TEST_F(QuicProcessDataTest, ProcessDataWithGarbageAtEnd) { TEST_F(QuicProcessDataTest, ProcessDataWithGarbageAtEnd) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
client->getNonConstConn().qLogger = qLogger; client->getNonConstConn().qLogger = qLogger;
auto serverHello = IOBuf::copyBuffer("Fake SHLO"); auto serverHello = IOBuf::copyBuffer("Fake SHLO");
PacketNum nextPacketNum = initialPacketNum++; PacketNum nextPacketNum = initialPacketNum++;
@@ -5318,7 +5318,7 @@ TEST_P(QuicProcessDataTest, ProcessDataHeaderOnly) {
ConnectionId(std::vector<uint8_t>(connIdSize, 1)); ConnectionId(std::vector<uint8_t>(connIdSize, 1));
setConnectionIds(); setConnectionIds();
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
client->getNonConstConn().qLogger = qLogger; client->getNonConstConn().qLogger = qLogger;
auto serverHello = IOBuf::copyBuffer("Fake SHLO"); auto serverHello = IOBuf::copyBuffer("Fake SHLO");
PacketNum nextPacketNum = initialPacketNum++; PacketNum nextPacketNum = initialPacketNum++;

2
quic/congestion_control/test/BbrBandwidthSamplerTest.cpp
View File

@@ -136,7 +136,7 @@ TEST_F(BbrBandwidthSamplerTest, SampleExpiration) {
TEST_F(BbrBandwidthSamplerTest, AppLimited) { TEST_F(BbrBandwidthSamplerTest, AppLimited) {
QuicConnectionStateBase conn(QuicNodeType::Client); QuicConnectionStateBase conn(QuicNodeType::Client);
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn.qLogger = qLogger; conn.qLogger = qLogger;
BbrBandwidthSampler sampler(conn); BbrBandwidthSampler sampler(conn);

6
quic/congestion_control/test/BbrTest.cpp
View File

@@ -37,7 +37,7 @@ TEST_F(BbrTest, InitStates) {
TEST_F(BbrTest, Recovery) { TEST_F(BbrTest, Recovery) {
QuicConnectionStateBase conn(QuicNodeType::Client); QuicConnectionStateBase conn(QuicNodeType::Client);
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn.qLogger = qLogger; conn.qLogger = qLogger;
conn.udpSendPacketLen = 1000; conn.udpSendPacketLen = 1000;
conn.transportSettings.initCwndInMss = 500; // Make a really large initCwnd conn.transportSettings.initCwndInMss = 500; // Make a really large initCwnd
@@ -374,7 +374,7 @@ TEST_F(BbrTest, NoLargestAckedPacketNoCrash) {
TEST_F(BbrTest, AckAggregation) { TEST_F(BbrTest, AckAggregation) {
QuicConnectionStateBase conn(QuicNodeType::Client); QuicConnectionStateBase conn(QuicNodeType::Client);
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn.qLogger = qLogger; conn.qLogger = qLogger;
conn.udpSendPacketLen = 1000; conn.udpSendPacketLen = 1000;
BbrCongestionController bbr(conn); BbrCongestionController bbr(conn);
@@ -559,7 +559,7 @@ TEST_F(BbrTest, BytesCounting) {
TEST_F(BbrTest, AppIdle) { TEST_F(BbrTest, AppIdle) {
QuicConnectionStateBase conn(QuicNodeType::Client); QuicConnectionStateBase conn(QuicNodeType::Client);
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn.qLogger = qLogger; conn.qLogger = qLogger;
BbrCongestionController bbr(conn); BbrCongestionController bbr(conn);

10
quic/congestion_control/test/CopaTest.cpp
View File

@@ -145,7 +145,7 @@ TEST_F(CopaTest, TestWritableBytes) {
TEST_F(CopaTest, PersistentCongestion) { TEST_F(CopaTest, PersistentCongestion) {
QuicServerConnectionState conn; QuicServerConnectionState conn;
Copa copa(conn); Copa copa(conn);
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn.qLogger = qLogger; conn.qLogger = qLogger;
EXPECT_TRUE(copa.inSlowStart()); EXPECT_TRUE(copa.inSlowStart());
@@ -177,7 +177,7 @@ TEST_F(CopaTest, PersistentCongestion) {
TEST_F(CopaTest, RemoveBytesWithoutLossOrAck) { TEST_F(CopaTest, RemoveBytesWithoutLossOrAck) {
QuicServerConnectionState conn; QuicServerConnectionState conn;
Copa copa(conn); Copa copa(conn);
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn.qLogger = qLogger; conn.qLogger = qLogger;
EXPECT_TRUE(copa.inSlowStart()); EXPECT_TRUE(copa.inSlowStart());
@@ -208,7 +208,7 @@ TEST_F(CopaTest, RemoveBytesWithoutLossOrAck) {
TEST_F(CopaTest, TestSlowStartAck) { TEST_F(CopaTest, TestSlowStartAck) {
QuicServerConnectionState conn; QuicServerConnectionState conn;
Copa copa(conn); Copa copa(conn);
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn.qLogger = qLogger; conn.qLogger = qLogger;
EXPECT_TRUE(copa.inSlowStart()); EXPECT_TRUE(copa.inSlowStart());
// initial cwnd = 10 packets // initial cwnd = 10 packets
@@ -346,7 +346,7 @@ TEST_F(CopaTest, TestVelocity) {
QuicServerConnectionState conn; QuicServerConnectionState conn;
conn.transportSettings.pacingTimerTickInterval = 10ms; conn.transportSettings.pacingTimerTickInterval = 10ms;
Copa copa(conn); Copa copa(conn);
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn.qLogger = qLogger; conn.qLogger = qLogger;
conn.transportSettings.pacingEnabled = true; conn.transportSettings.pacingEnabled = true;
@@ -439,7 +439,7 @@ TEST_F(CopaTest, TestVelocity) {
TEST_F(CopaTest, NoLargestAckedPacketNoCrash) { TEST_F(CopaTest, NoLargestAckedPacketNoCrash) {
QuicServerConnectionState conn; QuicServerConnectionState conn;
Copa copa(conn); Copa copa(conn);
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn.qLogger = qLogger; conn.qLogger = qLogger;
CongestionController::LossEvent loss; CongestionController::LossEvent loss;
loss.largestLostPacketNum = 0; loss.largestLostPacketNum = 0;

8
quic/congestion_control/test/CubicTest.cpp
View File

@@ -42,7 +42,7 @@ TEST_F(CubicTest, AckIncreaseWritable) {
TEST_F(CubicTest, PersistentCongestion) { TEST_F(CubicTest, PersistentCongestion) {
QuicConnectionStateBase conn(QuicNodeType::Client); QuicConnectionStateBase conn(QuicNodeType::Client);
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn.qLogger = qLogger; conn.qLogger = qLogger;
Cubic cubic(conn, std::numeric_limits<uint64_t>::max(), false); Cubic cubic(conn, std::numeric_limits<uint64_t>::max(), false);
auto initCwnd = cubic.getWritableBytes(); auto initCwnd = cubic.getWritableBytes();
@@ -113,7 +113,7 @@ TEST_F(CubicTest, PersistentCongestion) {
TEST_F(CubicTest, CwndIncreaseAfterReduction) { TEST_F(CubicTest, CwndIncreaseAfterReduction) {
QuicConnectionStateBase conn(QuicNodeType::Client); QuicConnectionStateBase conn(QuicNodeType::Client);
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn.qLogger = qLogger; conn.qLogger = qLogger;
conn.udpSendPacketLen = 200; conn.udpSendPacketLen = 200;
// initCwnd > initSsthresh: an ack will immediately make the state machine // initCwnd > initSsthresh: an ack will immediately make the state machine
@@ -176,7 +176,7 @@ TEST_F(CubicTest, CwndIncreaseAfterReduction) {
TEST_F(CubicTest, AppIdle) { TEST_F(CubicTest, AppIdle) {
QuicConnectionStateBase conn(QuicNodeType::Client); QuicConnectionStateBase conn(QuicNodeType::Client);
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn.qLogger = qLogger; conn.qLogger = qLogger;
conn.udpSendPacketLen = 1500; conn.udpSendPacketLen = 1500;
TestingCubic cubic(conn); TestingCubic cubic(conn);
@@ -242,7 +242,7 @@ TEST_F(CubicTest, PacingGain) {
auto mockPacer = std::make_unique<MockPacer>(); auto mockPacer = std::make_unique<MockPacer>();
auto rawPacer = mockPacer.get(); auto rawPacer = mockPacer.get();
conn.pacer = std::move(mockPacer); conn.pacer = std::move(mockPacer);
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn.qLogger = qLogger; conn.qLogger = qLogger;
conn.udpSendPacketLen = 1500; conn.udpSendPacketLen = 1500;
Cubic cubic(conn); Cubic cubic(conn);

4
quic/flowcontrol/test/QuicFlowControlTest.cpp
View File

@@ -592,7 +592,7 @@ TEST_F(QuicFlowControlTest, UpdateBadFlowControlOnStreamData) {
} }
TEST_F(QuicFlowControlTest, UpdateFlowControlOnRead) { TEST_F(QuicFlowControlTest, UpdateFlowControlOnRead) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn_.qLogger = qLogger; conn_.qLogger = qLogger;
StreamId id = 3; StreamId id = 3;
@@ -677,7 +677,7 @@ TEST_F(QuicFlowControlTest, HandleStreamWindowUpdate) {
StreamId id = 3; StreamId id = 3;
QuicStreamState stream(id, conn_); QuicStreamState stream(id, conn_);
stream.flowControlState.peerAdvertisedMaxOffset = 200; stream.flowControlState.peerAdvertisedMaxOffset = 200;
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn_.qLogger = qLogger; conn_.qLogger = qLogger;
handleStreamWindowUpdate(stream, 300, 2); handleStreamWindowUpdate(stream, 300, 2);

2
quic/logging/QLogger.h
View File

@@ -34,7 +34,7 @@ class QLogger {
std::chrono::steady_clock::now()}; std::chrono::steady_clock::now()};
VantagePoint vantagePoint; VantagePoint vantagePoint;
std::string protocolType; std::string protocolType;
QLogger() = default; QLogger() = delete;
virtual ~QLogger() = default; virtual ~QLogger() = default;
virtual void addPacket( virtual void addPacket(
const RegularQuicPacket& regularPacket, const RegularQuicPacket& regularPacket,

4
quic/logging/QLoggerConstants.cpp
View File

@@ -11,9 +11,9 @@
namespace quic { namespace quic {
folly::StringPiece vantagePointString(VantagePoint vantagePoint) noexcept { folly::StringPiece vantagePointString(VantagePoint vantagePoint) noexcept {
switch (vantagePoint) { switch (vantagePoint) {
case VantagePoint::CLIENT: case VantagePoint::Client:
return kQLogClientVantagePoint; return kQLogClientVantagePoint;
case VantagePoint::SERVER: case VantagePoint::Server:
return kQLogServerVantagePoint; return kQLogServerVantagePoint;
} }
folly::assume_unreachable(); folly::assume_unreachable();

11
quic/logging/QLoggerConstants.h
View File

@@ -9,6 +9,7 @@
#pragma once #pragma once
#include <folly/String.h> #include <folly/String.h>
#include "quic/QuicConstants.h"
namespace quic { namespace quic {
constexpr folly::StringPiece kShortHeaderPacketType = "1RTT"; constexpr folly::StringPiece kShortHeaderPacketType = "1RTT";
@@ -79,12 +80,10 @@ constexpr auto kOnHeaders = "on headers";
constexpr auto kOnError = "on error"; constexpr auto kOnError = "on error";
constexpr auto kPushPromise = "push promise"; constexpr auto kPushPromise = "push promise";
enum class VantagePoint : uint8_t { constexpr folly::StringPiece kQLogServerVantagePoint = "Server";
CLIENT, constexpr folly::StringPiece kQLogClientVantagePoint = "Client";
SERVER,
}; using VantagePoint = QuicNodeType;
constexpr folly::StringPiece kQLogServerVantagePoint = "SERVER";
constexpr folly::StringPiece kQLogClientVantagePoint = "CLIENT";
folly::StringPiece vantagePointString(VantagePoint vantagePoint) noexcept; folly::StringPiece vantagePointString(VantagePoint vantagePoint) noexcept;

8
quic/logging/QLoggerTypes.cpp
View File

@@ -769,9 +769,9 @@ folly::dynamic QLogStreamStateUpdateEvent::toDynamic() const {
data["id"] = id; data["id"] = id;
data["update"] = update; data["update"] = update;
if (timeSinceStreamCreation) { if (timeSinceStreamCreation) {
if (update == kOnEOM && vantagePoint_ == VantagePoint::CLIENT) { if (update == kOnEOM && vantagePoint_ == VantagePoint::Client) {
data["ttlb"] = timeSinceStreamCreation->count(); data["ttlb"] = timeSinceStreamCreation->count();
} else if (update == kOnHeaders && vantagePoint_ == VantagePoint::CLIENT) { } else if (update == kOnHeaders && vantagePoint_ == VantagePoint::Client) {
data["ttfb"] = timeSinceStreamCreation->count(); data["ttfb"] = timeSinceStreamCreation->count();
} else { } else {
data["ms_since_creation"] = timeSinceStreamCreation->count(); data["ms_since_creation"] = timeSinceStreamCreation->count();
@@ -802,7 +802,7 @@ folly::dynamic QLogConnectionMigrationEvent::toDynamic() const {
folly::dynamic data = folly::dynamic::object(); folly::dynamic data = folly::dynamic::object();
data["intentional"] = intentionalMigration_; data["intentional"] = intentionalMigration_;
if (vantagePoint_ == VantagePoint::CLIENT) { if (vantagePoint_ == VantagePoint::Client) {
data["type"] = "initiating"; data["type"] = "initiating";
} else { } else {
data["type"] = "accepting"; data["type"] = "accepting";
@@ -831,7 +831,7 @@ folly::dynamic QLogPathValidationEvent::toDynamic() const {
folly::dynamic data = folly::dynamic::object(); folly::dynamic data = folly::dynamic::object();
data["success"] = success_; data["success"] = success_;
if (vantagePoint_ == VantagePoint::CLIENT) { if (vantagePoint_ == VantagePoint::Client) {
data["vantagePoint"] = "client"; data["vantagePoint"] = "client";
} else { } else {
data["vantagePoint"] = "server"; data["vantagePoint"] = "server";

2
quic/logging/test/Mocks.h
View File

@@ -14,6 +14,8 @@
namespace quic::test { namespace quic::test {
class MockQLogger : public QLogger { class MockQLogger : public QLogger {
public: public:
MockQLogger() = delete;
MockQLogger(VantagePoint vp) : QLogger(vp, kHTTP3ProtocolType){};
~MockQLogger() override = default; ~MockQLogger() override = default;
MOCK_METHOD2(addPacket, void(const RegularQuicPacket&, uint64_t)); MOCK_METHOD2(addPacket, void(const RegularQuicPacket&, uint64_t));
MOCK_METHOD3( MOCK_METHOD3(

96
quic/logging/test/QLoggerTest.cpp
View File

@@ -32,8 +32,8 @@ TEST_F(QLoggerTest, TestRegularWritePacket) {
RegularQuicWritePacket regularWritePacket = RegularQuicWritePacket regularWritePacket =
createRegularQuicWritePacket(streamId, offset, len, fin); createRegularQuicWritePacket(streamId, offset, len, fin);
FileQLogger q(VantagePoint::CLIENT, fakeProtocolType); FileQLogger q(VantagePoint::Client, fakeProtocolType);
EXPECT_EQ(q.vantagePoint, VantagePoint::CLIENT); EXPECT_EQ(q.vantagePoint, VantagePoint::Client);
EXPECT_EQ(q.protocolType, fakeProtocolType); EXPECT_EQ(q.protocolType, fakeProtocolType);
q.addPacket(regularWritePacket, 10); q.addPacket(regularWritePacket, 10);
@@ -55,7 +55,7 @@ TEST_F(QLoggerTest, TestRegularPacket) {
regularQuicPacket.frames.emplace_back(std::move(frame)); regularQuicPacket.frames.emplace_back(std::move(frame));
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addPacket(regularQuicPacket, 10); q.addPacket(regularQuicPacket, 10);
std::unique_ptr<QLogEvent> p = std::move(q.logs[0]); std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -70,7 +70,7 @@ TEST_F(QLoggerTest, TestRegularPacket) {
TEST_F(QLoggerTest, TestVersionNegotiationPacket) { TEST_F(QLoggerTest, TestVersionNegotiationPacket) {
bool isPacketRecvd = false; bool isPacketRecvd = false;
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
auto packet = createVersionNegotiationPacket(); auto packet = createVersionNegotiationPacket();
q.addPacket(packet, 10, isPacketRecvd); q.addPacket(packet, 10, isPacketRecvd);
@@ -82,7 +82,7 @@ TEST_F(QLoggerTest, TestVersionNegotiationPacket) {
} }
TEST_F(QLoggerTest, ConnectionCloseEvent) { TEST_F(QLoggerTest, ConnectionCloseEvent) {
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
auto error = toString(LocalErrorCode::CONNECTION_RESET); auto error = toString(LocalErrorCode::CONNECTION_RESET);
q.addConnectionClose(error.str(), "Connection close", true, false); q.addConnectionClose(error.str(), "Connection close", true, false);
@@ -94,7 +94,7 @@ TEST_F(QLoggerTest, ConnectionCloseEvent) {
} }
TEST_F(QLoggerTest, TransportSummaryEvent) { TEST_F(QLoggerTest, TransportSummaryEvent) {
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addTransportSummary(8, 9, 5, 3, 2, 554, 100, 32, 134, 238); q.addTransportSummary(8, 9, 5, 3, 2, 554, 100, 32, 134, 238);
std::unique_ptr<QLogEvent> p = std::move(q.logs[0]); std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -113,7 +113,7 @@ TEST_F(QLoggerTest, TransportSummaryEvent) {
} }
TEST_F(QLoggerTest, CongestionMetricUpdateEvent) { TEST_F(QLoggerTest, CongestionMetricUpdateEvent) {
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addCongestionMetricUpdate( q.addCongestionMetricUpdate(
20, 20,
30, 30,
@@ -136,7 +136,7 @@ TEST_F(QLoggerTest, CongestionMetricUpdateEvent) {
} }
TEST_F(QLoggerTest, PacingMetricUpdateEvent) { TEST_F(QLoggerTest, PacingMetricUpdateEvent) {
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addPacingMetricUpdate(10, 30us); q.addPacingMetricUpdate(10, 30us);
std::unique_ptr<QLogEvent> p = std::move(q.logs[0]); std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -147,7 +147,7 @@ TEST_F(QLoggerTest, PacingMetricUpdateEvent) {
} }
TEST_F(QLoggerTest, AppIdleUpdateEvent) { TEST_F(QLoggerTest, AppIdleUpdateEvent) {
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addAppIdleUpdate(kAppIdle, false); q.addAppIdleUpdate(kAppIdle, false);
std::unique_ptr<QLogEvent> p = std::move(q.logs[0]); std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -158,7 +158,7 @@ TEST_F(QLoggerTest, AppIdleUpdateEvent) {
} }
TEST_F(QLoggerTest, PacketDropEvent) { TEST_F(QLoggerTest, PacketDropEvent) {
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addPacketDrop(5, kCipherUnavailable); q.addPacketDrop(5, kCipherUnavailable);
std::unique_ptr<QLogEvent> p = std::move(q.logs[0]); std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -169,7 +169,7 @@ TEST_F(QLoggerTest, PacketDropEvent) {
} }
TEST_F(QLoggerTest, DatagramReceivedEvent) { TEST_F(QLoggerTest, DatagramReceivedEvent) {
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addDatagramReceived(100); q.addDatagramReceived(100);
std::unique_ptr<QLogEvent> p = std::move(q.logs[0]); std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -179,7 +179,7 @@ TEST_F(QLoggerTest, DatagramReceivedEvent) {
} }
TEST_F(QLoggerTest, LossAlarmEvent) { TEST_F(QLoggerTest, LossAlarmEvent) {
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addLossAlarm(PacketNum{1}, 3983, 893, kPtoAlarm); q.addLossAlarm(PacketNum{1}, 3983, 893, kPtoAlarm);
std::unique_ptr<QLogEvent> p = std::move(q.logs[0]); std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -192,7 +192,7 @@ TEST_F(QLoggerTest, LossAlarmEvent) {
} }
TEST_F(QLoggerTest, PacketsLostEvent) { TEST_F(QLoggerTest, PacketsLostEvent) {
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addPacketsLost(PacketNum{42}, 332, 89); q.addPacketsLost(PacketNum{42}, 332, 89);
std::unique_ptr<QLogEvent> p = std::move(q.logs[0]); std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -204,7 +204,7 @@ TEST_F(QLoggerTest, PacketsLostEvent) {
} }
TEST_F(QLoggerTest, TransportStateUpdateEvent) { TEST_F(QLoggerTest, TransportStateUpdateEvent) {
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
std::string update = "start"; std::string update = "start";
q.addTransportStateUpdate(update); q.addTransportStateUpdate(update);
@@ -215,7 +215,7 @@ TEST_F(QLoggerTest, TransportStateUpdateEvent) {
} }
TEST_F(QLoggerTest, PacketBufferedEvent) { TEST_F(QLoggerTest, PacketBufferedEvent) {
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addPacketBuffered(PacketNum{10}, ProtectionType::Handshake, 100); q.addPacketBuffered(PacketNum{10}, ProtectionType::Handshake, 100);
std::unique_ptr<QLogEvent> p = std::move(q.logs[0]); std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -227,7 +227,7 @@ TEST_F(QLoggerTest, PacketBufferedEvent) {
} }
TEST_F(QLoggerTest, MetricUpdateEvent) { TEST_F(QLoggerTest, MetricUpdateEvent) {
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addMetricUpdate(10us, 11us, 12us, 13us); q.addMetricUpdate(10us, 11us, 12us, 13us);
std::unique_ptr<QLogEvent> p = std::move(q.logs[0]); std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -240,7 +240,7 @@ TEST_F(QLoggerTest, MetricUpdateEvent) {
} }
TEST_F(QLoggerTest, StreamStateUpdateEvent) { TEST_F(QLoggerTest, StreamStateUpdateEvent) {
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addStreamStateUpdate(streamId, kAbort, 20ms); q.addStreamStateUpdate(streamId, kAbort, 20ms);
std::unique_ptr<QLogEvent> p = std::move(q.logs[0]); std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -252,7 +252,7 @@ TEST_F(QLoggerTest, StreamStateUpdateEvent) {
} }
TEST_F(QLoggerTest, PacketPaddingFrameEvent) { TEST_F(QLoggerTest, PacketPaddingFrameEvent) {
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
auto packet = createPacketWithPaddingFrames(); auto packet = createPacketWithPaddingFrames();
q.addPacket(packet, 100); q.addPacket(packet, 100);
@@ -322,8 +322,8 @@ TEST_F(QLoggerTest, QLoggerFollyDynamic) {
], ],
"title": "mvfst qlog from single connection", "title": "mvfst qlog from single connection",
"vantage_point": { "vantage_point": {
"name": "SERVER", "name": "Server",
"type": "SERVER" "type": "Server"
} }
} }
] ]
@@ -336,7 +336,7 @@ TEST_F(QLoggerTest, QLoggerFollyDynamic) {
regularQuicPacket.frames.emplace_back(std::move(frame)); regularQuicPacket.frames.emplace_back(std::move(frame));
FileQLogger q(VantagePoint::SERVER); FileQLogger q(VantagePoint::Server);
q.addPacket(regularQuicPacket, 10); q.addPacket(regularQuicPacket, 10);
q.logs[0]->refTime = 31us; q.logs[0]->refTime = 31us;
@@ -379,7 +379,7 @@ TEST_F(QLoggerTest, RegularPacketFollyDynamic) {
regularQuicPacket.frames.emplace_back(std::move(frame)); regularQuicPacket.frames.emplace_back(std::move(frame));
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addPacket(regularQuicPacket, 10); q.addPacket(regularQuicPacket, 10);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
@@ -418,7 +418,7 @@ TEST_F(QLoggerTest, RegularWritePacketFollyDynamic) {
RegularQuicWritePacket packet = RegularQuicWritePacket packet =
createRegularQuicWritePacket(streamId, offset, len, fin); createRegularQuicWritePacket(streamId, offset, len, fin);
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.dcid = getTestConnectionId(0); q.dcid = getTestConnectionId(0);
q.scid = getTestConnectionId(1); q.scid = getTestConnectionId(1);
q.addPacket(packet, 10); q.addPacket(packet, 10);
@@ -463,7 +463,7 @@ TEST_F(QLoggerTest, RegularPacketAckFrameFollyDynamic) {
])"); ])");
RegularQuicWritePacket packet = createPacketWithAckFrames(); RegularQuicWritePacket packet = createPacketWithAckFrames();
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addPacket(packet, 1001); q.addPacket(packet, 1001);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -493,7 +493,7 @@ TEST_F(QLoggerTest, VersionPacketFollyDynamic) {
])"); ])");
auto packet = createVersionNegotiationPacket(); auto packet = createVersionNegotiationPacket();
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.dcid = getTestConnectionId(0); q.dcid = getTestConnectionId(0);
q.scid = getTestConnectionId(1); q.scid = getTestConnectionId(1);
q.addPacket(packet, 10, isPacketRecvd); q.addPacket(packet, 10, isPacketRecvd);
@@ -607,14 +607,14 @@ TEST_F(QLoggerTest, AddingMultiplePacketEvents) {
], ],
"title": "mvfst qlog from single connection", "title": "mvfst qlog from single connection",
"vantage_point": { "vantage_point": {
"name": "SERVER", "name": "Server",
"type": "SERVER" "type": "Server"
} }
} }
] ]
})"); })");
FileQLogger q(VantagePoint::SERVER); FileQLogger q(VantagePoint::Server);
auto versionPacket = createVersionNegotiationPacket(); auto versionPacket = createVersionNegotiationPacket();
RegularQuicWritePacket regPacket = createPacketWithAckFrames(); RegularQuicWritePacket regPacket = createPacketWithAckFrames();
auto packet = createStreamPacket( auto packet = createStreamPacket(
@@ -687,7 +687,7 @@ TEST_F(QLoggerTest, AddingMultipleFrames) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
RegularQuicWritePacket packet = RegularQuicWritePacket packet =
createNewPacket(100, PacketNumberSpace::Initial); createNewPacket(100, PacketNumberSpace::Initial);
@@ -722,7 +722,7 @@ TEST_F(QLoggerTest, ConnectionCloseFollyDynamic) {
} }
]])"); ]])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
auto error = toString(LocalErrorCode::CONNECTION_RESET); auto error = toString(LocalErrorCode::CONNECTION_RESET);
q.addConnectionClose(error.str(), "Connection changed", true, false); q.addConnectionClose(error.str(), "Connection changed", true, false);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
@@ -754,7 +754,7 @@ TEST_F(QLoggerTest, TransportSummaryFollyDynamic) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addTransportSummary(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); q.addTransportSummary(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -780,7 +780,7 @@ TEST_F(QLoggerTest, CongestionMetricUpdateFollyDynamic) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addCongestionMetricUpdate( q.addCongestionMetricUpdate(
20, 20,
30, 30,
@@ -807,7 +807,7 @@ TEST_F(QLoggerTest, PacingMetricUpdateFollyDynamic) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addPacingMetricUpdate(20, 30us); q.addPacingMetricUpdate(20, 30us);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -830,7 +830,7 @@ TEST_F(QLoggerTest, AppIdleFollyDynamic) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addAppIdleUpdate(kAppIdle, true); q.addAppIdleUpdate(kAppIdle, true);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -853,7 +853,7 @@ TEST_F(QLoggerTest, PacketDropFollyDynamic) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addPacketDrop(100, kMaxBuffered); q.addPacketDrop(100, kMaxBuffered);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -875,7 +875,7 @@ TEST_F(QLoggerTest, DatagramReceivedFollyDynamic) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addDatagramReceived(8); q.addDatagramReceived(8);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -900,7 +900,7 @@ TEST_F(QLoggerTest, LossAlarmFollyDynamic) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addLossAlarm(PacketNum{100}, 14, 38, kHandshakeAlarm); q.addLossAlarm(PacketNum{100}, 14, 38, kHandshakeAlarm);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -924,7 +924,7 @@ TEST_F(QLoggerTest, PacketsLostFollyDynamic) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addPacketsLost(PacketNum{10}, 9, 8); q.addPacketsLost(PacketNum{10}, 9, 8);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -946,7 +946,7 @@ TEST_F(QLoggerTest, TransportStateUpdateFollyDynamic) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addTransportStateUpdate("transport ready"); q.addTransportStateUpdate("transport ready");
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -970,7 +970,7 @@ TEST_F(QLoggerTest, PacketBufferedFollyDynamic) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addPacketBuffered(PacketNum{10}, ProtectionType::Handshake, 100); q.addPacketBuffered(PacketNum{10}, ProtectionType::Handshake, 100);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -995,7 +995,7 @@ TEST_F(QLoggerTest, MetricUpdateFollyDynamic) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addMetricUpdate(10us, 11us, 12us, 13us); q.addMetricUpdate(10us, 11us, 12us, 13us);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -1019,7 +1019,7 @@ TEST_F(QLoggerTest, StreamStateUpdateFollyDynamicTTFB) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addStreamStateUpdate(streamId, kOnHeaders, 20ms); q.addStreamStateUpdate(streamId, kOnHeaders, 20ms);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -1043,7 +1043,7 @@ TEST_F(QLoggerTest, StreamStateUpdateFollyDynamicTTLB) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addStreamStateUpdate(streamId, kOnEOM, 20ms); q.addStreamStateUpdate(streamId, kOnEOM, 20ms);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -1068,7 +1068,7 @@ TEST_F(
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addStreamStateUpdate(streamId, kOnEOM, folly::none); q.addStreamStateUpdate(streamId, kOnEOM, folly::none);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -1092,7 +1092,7 @@ TEST_F(QLoggerTest, StreamStateUpdateFollyDynamic) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addStreamStateUpdate(streamId, kAbort, 20ms); q.addStreamStateUpdate(streamId, kAbort, 20ms);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -1124,7 +1124,7 @@ TEST_F(QLoggerTest, PaddingFramesFollyDynamic) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
auto packet = createPacketWithPaddingFrames(); auto packet = createPacketWithPaddingFrames();
q.addPacket(packet, 100); q.addPacket(packet, 100);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
@@ -1148,7 +1148,7 @@ TEST_F(QLoggerTest, ConnectionMigration) {
] ]
])"); ])");
FileQLogger q(VantagePoint::CLIENT); FileQLogger q(VantagePoint::Client);
q.addConnectionMigrationUpdate(true); q.addConnectionMigrationUpdate(true);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -1171,7 +1171,7 @@ TEST_F(QLoggerTest, PathValidation) {
] ]
])"); ])");
FileQLogger q(VantagePoint::SERVER); FileQLogger q(VantagePoint::Server);
q.addPathValidationEvent(false); q.addPathValidationEvent(false);
folly::dynamic gotDynamic = q.toDynamic(); folly::dynamic gotDynamic = q.toDynamic();
gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time

12
quic/loss/test/QuicLossFunctionsTest.cpp
View File

@@ -537,7 +537,7 @@ TEST_F(QuicLossFunctionsTest, TestReorderingThreshold) {
TEST_F(QuicLossFunctionsTest, TestHandleAckForLoss) { TEST_F(QuicLossFunctionsTest, TestHandleAckForLoss) {
auto conn = createConn(); auto conn = createConn();
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
conn->qLogger = qLogger; conn->qLogger = qLogger;
conn->lossState.ptoCount = 100; conn->lossState.ptoCount = 100;
conn->lossState.reorderingThreshold = 10; conn->lossState.reorderingThreshold = 10;
@@ -581,7 +581,7 @@ TEST_F(QuicLossFunctionsTest, TestHandleAckForLoss) {
TEST_F(QuicLossFunctionsTest, TestHandleAckedPacket) { TEST_F(QuicLossFunctionsTest, TestHandleAckedPacket) {
auto conn = createConn(); auto conn = createConn();
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
conn->qLogger = qLogger; conn->qLogger = qLogger;
conn->lossState.ptoCount = 10; conn->lossState.ptoCount = 10;
conn->lossState.handshakeAlarmCount = 5; conn->lossState.handshakeAlarmCount = 5;
@@ -857,7 +857,7 @@ TEST_F(
QuicLossFunctionsTest, QuicLossFunctionsTest,
WhenHandshakeOutstandingAlarmMarksAllHandshakeAsLoss) { WhenHandshakeOutstandingAlarmMarksAllHandshakeAsLoss) {
auto conn = createConn(); auto conn = createConn();
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
conn->qLogger = qLogger; conn->qLogger = qLogger;
auto mockCongestionController = std::make_unique<MockCongestionController>(); auto mockCongestionController = std::make_unique<MockCongestionController>();
auto rawCongestionController = mockCongestionController.get(); auto rawCongestionController = mockCongestionController.get();
@@ -910,7 +910,7 @@ TEST_F(
TEST_F(QuicLossFunctionsTest, HandshakeAlarmWithOneRttCipher) { TEST_F(QuicLossFunctionsTest, HandshakeAlarmWithOneRttCipher) {
auto conn = createClientConn(); auto conn = createClientConn();
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn->qLogger = qLogger; conn->qLogger = qLogger;
conn->oneRttWriteCipher = createNoOpAead(); conn->oneRttWriteCipher = createNoOpAead();
conn->lossState.currentAlarmMethod = LossState::AlarmMethod::Handshake; conn->lossState.currentAlarmMethod = LossState::AlarmMethod::Handshake;
@@ -1202,7 +1202,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossProcessedPacket) {
TEST_F(QuicLossFunctionsTest, TestTotalPTOCount) { TEST_F(QuicLossFunctionsTest, TestTotalPTOCount) {
auto conn = createConn(); auto conn = createConn();
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
conn->qLogger = qLogger; conn->qLogger = qLogger;
conn->lossState.totalPTOCount = 100; conn->lossState.totalPTOCount = 100;
EXPECT_CALL(*transportInfoCb_, onPTO()); EXPECT_CALL(*transportInfoCb_, onPTO());
@@ -1222,7 +1222,7 @@ TEST_F(QuicLossFunctionsTest, TestTotalPTOCount) {
TEST_F(QuicLossFunctionsTest, TestExceedsMaxPTOThrows) { TEST_F(QuicLossFunctionsTest, TestExceedsMaxPTOThrows) {
auto conn = createConn(); auto conn = createConn();
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
conn->qLogger = qLogger; conn->qLogger = qLogger;
conn->transportSettings.maxNumPTOs = 3; conn->transportSettings.maxNumPTOs = 3;
EXPECT_CALL(*transportInfoCb_, onPTO()).Times(3); EXPECT_CALL(*transportInfoCb_, onPTO()).Times(3);

32
quic/server/test/QuicServerTransportTest.cpp
View File

@@ -929,7 +929,7 @@ TEST_F(QuicServerTransportTest, TestCloseConnectionWithNoError) {
} }
TEST_F(QuicServerTransportTest, TestClientAddressChanges) { TEST_F(QuicServerTransportTest, TestClientAddressChanges) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
server->getNonConstConn().qLogger = qLogger; server->getNonConstConn().qLogger = qLogger;
StreamId streamId = 4; StreamId streamId = 4;
clientAddr = folly::SocketAddress("127.0.0.1", 2000); clientAddr = folly::SocketAddress("127.0.0.1", 2000);
@@ -1028,7 +1028,7 @@ TEST_F(QuicServerTransportTest, ReceivePacketAfterLocalError) {
} }
TEST_F(QuicServerTransportTest, ReceiveCloseAfterLocalError) { TEST_F(QuicServerTransportTest, ReceiveCloseAfterLocalError) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
server->getNonConstConn().qLogger = qLogger; server->getNonConstConn().qLogger = qLogger;
ShortHeader header( ShortHeader header(
@@ -1735,7 +1735,7 @@ TEST_F(QuicServerTransportTest, StopSendingLossAfterStreamClosed) {
TEST_F(QuicServerTransportTest, TestCloneStopSending) { TEST_F(QuicServerTransportTest, TestCloneStopSending) {
auto streamId = server->createBidirectionalStream().value(); auto streamId = server->createBidirectionalStream().value();
auto qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Server);
server->getNonConstConn().qLogger = qLogger; server->getNonConstConn().qLogger = qLogger;
server->getNonConstConn().streamManager->getStream(streamId); server->getNonConstConn().streamManager->getStream(streamId);
// knock every handshake outstanding packets out // knock every handshake outstanding packets out
@@ -1843,7 +1843,7 @@ TEST_F(QuicServerTransportTest, TestAckRstStream) {
} }
TEST_F(QuicServerTransportTest, ReceiveConnectionClose) { TEST_F(QuicServerTransportTest, ReceiveConnectionClose) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
server->getNonConstConn().qLogger = qLogger; server->getNonConstConn().qLogger = qLogger;
ShortHeader header( ShortHeader header(
@@ -1881,7 +1881,7 @@ TEST_F(QuicServerTransportTest, ReceiveConnectionClose) {
} }
TEST_F(QuicServerTransportTest, ReceiveApplicationClose) { TEST_F(QuicServerTransportTest, ReceiveApplicationClose) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
server->getNonConstConn().qLogger = qLogger; server->getNonConstConn().qLogger = qLogger;
ShortHeader header( ShortHeader header(
@@ -1923,7 +1923,7 @@ TEST_F(QuicServerTransportTest, ReceiveApplicationClose) {
} }
TEST_F(QuicServerTransportTest, ReceiveConnectionCloseTwice) { TEST_F(QuicServerTransportTest, ReceiveConnectionCloseTwice) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
server->getNonConstConn().qLogger = qLogger; server->getNonConstConn().qLogger = qLogger;
ShortHeader header( ShortHeader header(
ProtectionType::KeyPhaseZero, ProtectionType::KeyPhaseZero,
@@ -2149,7 +2149,7 @@ INSTANTIATE_TEST_CASE_P(
TEST_P( TEST_P(
QuicServerTransportAllowMigrationTest, QuicServerTransportAllowMigrationTest,
ReceiveProbingPacketFromChangedPeerAddress) { ReceiveProbingPacketFromChangedPeerAddress) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
server->getNonConstConn().qLogger = qLogger; server->getNonConstConn().qLogger = qLogger;
server->getNonConstConn().transportSettings.disableMigration = false; server->getNonConstConn().transportSettings.disableMigration = false;
@@ -2502,7 +2502,7 @@ TEST_P(
} }
TEST_F(QuicServerTransportTest, TooManyMigrations) { TEST_F(QuicServerTransportTest, TooManyMigrations) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
server->getNonConstConn().qLogger = qLogger; server->getNonConstConn().qLogger = qLogger;
server->getNonConstConn().transportSettings.disableMigration = false; server->getNonConstConn().transportSettings.disableMigration = false;
@@ -3257,7 +3257,7 @@ TEST_F(QuicUnencryptedServerTransportTest, TestUnencryptedStream) {
} }
TEST_F(QuicUnencryptedServerTransportTest, TestUnencryptedAck) { TEST_F(QuicUnencryptedServerTransportTest, TestUnencryptedAck) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
server->getNonConstConn().qLogger = qLogger; server->getNonConstConn().qLogger = qLogger;
WriteAckFrame::AckBlocks acks = {{1, 2}}; WriteAckFrame::AckBlocks acks = {{1, 2}};
auto expected = IOBuf::copyBuffer("hello"); auto expected = IOBuf::copyBuffer("hello");
@@ -3395,7 +3395,7 @@ TEST_F(QuicUnencryptedServerTransportTest, TestPendingOneRttData) {
TEST_F( TEST_F(
QuicUnencryptedServerTransportTest, QuicUnencryptedServerTransportTest,
TestReceiveClientFinishedFromChangedPeerAddress) { TestReceiveClientFinishedFromChangedPeerAddress) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
server->getNonConstConn().qLogger = qLogger; server->getNonConstConn().qLogger = qLogger;
recvClientHello(); recvClientHello();
@@ -3567,7 +3567,7 @@ TEST_F(QuicUnencryptedServerTransportTest, TestEncryptedDataBeforeCFIN) {
TEST_F( TEST_F(
QuicUnencryptedServerTransportTest, QuicUnencryptedServerTransportTest,
TestClearInFlightBytesLimitationAfterCFIN) { TestClearInFlightBytesLimitationAfterCFIN) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
server->getNonConstConn().qLogger = qLogger; server->getNonConstConn().qLogger = qLogger;
getFakeHandshakeLayer()->allowZeroRttKeys(); getFakeHandshakeLayer()->allowZeroRttKeys();
auto originalUdpSize = server->getConn().udpSendPacketLen; auto originalUdpSize = server->getConn().udpSendPacketLen;
@@ -3601,7 +3601,7 @@ TEST_F(
TEST_F( TEST_F(
QuicUnencryptedServerTransportTest, QuicUnencryptedServerTransportTest,
IncreaseLimitAfterReceivingNewPacket) { IncreaseLimitAfterReceivingNewPacket) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
server->getNonConstConn().qLogger = qLogger; server->getNonConstConn().qLogger = qLogger;
getFakeHandshakeLayer()->allowZeroRttKeys(); getFakeHandshakeLayer()->allowZeroRttKeys();
@@ -3634,7 +3634,7 @@ TEST_F(
} }
TEST_F(QuicUnencryptedServerTransportTest, TestGarbageData) { TEST_F(QuicUnencryptedServerTransportTest, TestGarbageData) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
server->getNonConstConn().qLogger = qLogger; server->getNonConstConn().qLogger = qLogger;
auto data = IOBuf::copyBuffer("bad data"); auto data = IOBuf::copyBuffer("bad data");
@@ -3787,7 +3787,7 @@ TEST_P(
QuicServerTransportPendingDataTest, QuicServerTransportPendingDataTest,
TestNoCipherProcessPendingZeroRttData) { TestNoCipherProcessPendingZeroRttData) {
server->getNonConstConn().qLogger = server->getNonConstConn().qLogger =
std::make_shared<quic::FileQLogger>(VantagePoint::SERVER); std::make_shared<quic::FileQLogger>(VantagePoint::Server);
recvClientHello(false); recvClientHello(false);
auto data = IOBuf::copyBuffer("bad data"); auto data = IOBuf::copyBuffer("bad data");
StreamId streamId = 2; StreamId streamId = 2;
@@ -3825,7 +3825,7 @@ TEST_P(
QuicServerTransportPendingDataTest, QuicServerTransportPendingDataTest,
TestNoCipherProcessPendingOneRttData) { TestNoCipherProcessPendingOneRttData) {
server->getNonConstConn().qLogger = server->getNonConstConn().qLogger =
std::make_shared<quic::FileQLogger>(VantagePoint::SERVER); std::make_shared<quic::FileQLogger>(VantagePoint::Server);
recvClientHello(); recvClientHello();
auto data = IOBuf::copyBuffer("bad data"); auto data = IOBuf::copyBuffer("bad data");
StreamId streamId = 2; StreamId streamId = 2;
@@ -3857,7 +3857,7 @@ TEST_P(
QuicServerTransportPendingDataTest, QuicServerTransportPendingDataTest,
TestNoCipherProcessingZeroAndOneRttData) { TestNoCipherProcessingZeroAndOneRttData) {
server->getNonConstConn().qLogger = server->getNonConstConn().qLogger =
std::make_shared<quic::FileQLogger>(VantagePoint::SERVER); std::make_shared<quic::FileQLogger>(VantagePoint::Server);
recvClientHello(false); recvClientHello(false);
auto data = IOBuf::copyBuffer("bad data"); auto data = IOBuf::copyBuffer("bad data");
StreamId streamId = 2; StreamId streamId = 2;

2
quic/state/stream/test/StreamStateFunctionsTest.cpp
View File

@@ -185,7 +185,7 @@ TEST_F(StreamStateFunctionsTests, ResetNoFlowControlGenerated) {
TEST_F(StreamStateFunctionsTests, ResetFlowControlGenerated) { TEST_F(StreamStateFunctionsTests, ResetFlowControlGenerated) {
QuicServerConnectionState conn; QuicServerConnectionState conn;
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
conn.qLogger = qLogger; conn.qLogger = qLogger;
StreamId id = 1; StreamId id = 1;

2
quic/state/test/AckHandlersTest.cpp
View File

@@ -741,7 +741,7 @@ TEST_P(AckHandlersTest, UpdateMaxAckDelay) {
// Ack only acks packets aren't outstanding, but TimeReordering still finds loss // Ack only acks packets aren't outstanding, but TimeReordering still finds loss
TEST_P(AckHandlersTest, AckNotOutstandingButLoss) { TEST_P(AckHandlersTest, AckNotOutstandingButLoss) {
QuicServerConnectionState conn; QuicServerConnectionState conn;
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
conn.qLogger = qLogger; conn.qLogger = qLogger;
conn.lossState.srtt = 200ms; conn.lossState.srtt = 200ms;

2
quic/state/test/QuicStateFunctionsTest.cpp
View File

@@ -412,7 +412,7 @@ TEST_F(QuicStateFunctionsTest, TestInvokeStreamStateMachineStreamError) {
TEST_F(QuicStateFunctionsTest, UpdateMinRtt) { TEST_F(QuicStateFunctionsTest, UpdateMinRtt) {
QuicServerConnectionState conn; QuicServerConnectionState conn;
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER); auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
conn.qLogger = qLogger; conn.qLogger = qLogger;
// First rtt sample, will be assign to both srtt and mrtt // First rtt sample, will be assign to both srtt and mrtt

2
quic/tools/tperf/test/PacingObserverTest.cpp
View File

@@ -16,7 +16,7 @@ namespace quic::test {
class QLogPacingObserverTest : public Test { class QLogPacingObserverTest : public Test {
public: public:
void SetUp() override { void SetUp() override {
auto qlogger = std::make_shared<MockQLogger>(); auto qlogger = std::make_shared<MockQLogger>(VantagePoint::Client);
mockQLogger_ = qlogger.get(); mockQLogger_ = qlogger.get();
qlogger_ = std::move(qlogger); qlogger_ = std::move(qlogger);
} }

2
quic/tools/tperf/tperf.cpp
View File

@@ -233,7 +233,7 @@ class TPerfServerTransportFactory : public quic::QuicServerTransportFactory {
evb, std::move(sock), *serverHandler, ctx); evb, std::move(sock), *serverHandler, ctx);
if (!FLAGS_server_qlogger_path.empty()) { if (!FLAGS_server_qlogger_path.empty()) {
auto qlogger = std::make_shared<TperfQLogger>( auto qlogger = std::make_shared<TperfQLogger>(
VantagePoint::SERVER, FLAGS_server_qlogger_path); VantagePoint::Server, FLAGS_server_qlogger_path);
setPacingObserver(qlogger, transport.get(), FLAGS_pacing_observer); setPacingObserver(qlogger, transport.get(), FLAGS_pacing_observer);
transport->setQLogger(std::move(qlogger)); transport->setQLogger(std::move(qlogger));
} }