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

Deprecate old connection callback

Browse Source 
Summary: Deprecate old connection callback

Reviewed By: jbeshay, lnicco

Differential Revision: D33695440

fbshipit-source-id: 043baa53b71453b5e2b9f60d890f1adcda7c65b5
This commit is contained in:
Konstantin Tsoy
2022-02-02 19:02:44 -08:00
committed by Facebook GitHub Bot
parent 0f9eedb347
commit dc79176a56
17 changed files with 52 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
quic/api/QuicSocket.h
View File

@@ -139,15 +139,6 @@ class QuicSocket {
onKnob(uint64_t /*knobSpace*/, uint64_t /*knobId*/, Buf /*knobBlob*/) {}
};
/**
* Callback for connection level events. This callback must be set at all
* times.
* This callback will be phased out with the two separate callbacks above to
* replace it.
*/
class ConnectionCallback : public ConnectionSetupCallback,
public ConnectionCallbackNew {};
/**
* Information about the transport, similar to what TCP has.
*/
@@ -216,11 +207,6 @@ class QuicSocket {
uint64_t numPacketsTxWithNewData{0};
};
/**
* Sets connection callback, must be set BEFORE using the socket.
*/
virtual void setConnectionCallback(ConnectionCallback* callback) = 0;
/**
* Sets connection setup callback. This callback must be set before using the
* socket.

17
quic/api/QuicTransportBase.cpp
View File

@@ -28,8 +28,7 @@ namespace quic {
QuicTransportBase::QuicTransportBase(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> socket,
bool useSplitConnectionCallbacks)
std::unique_ptr<folly::AsyncUDPSocket> socket)
: evb_(evb),
socket_(std::move(socket)),
lossTimeout_(this),
@@ -52,8 +51,7 @@ QuicTransportBase::QuicTransportBase(
writeLooper_(new FunctionLooper(
evb,
[this](bool fromTimer) { pacedWriteDataToSocket(fromTimer); },
LooperType::WriteLooper)),
useSplitConnectionCallbacks_(useSplitConnectionCallbacks) {
LooperType::WriteLooper)) {
writeLooper_->setPacingFunction([this]() -> auto {
if (isConnectionPaced(*conn_)) {
return conn_->pacer->getTimeUntilNextWrite();
@@ -398,12 +396,8 @@ void QuicTransportBase::closeImpl(
// connCallback_ could be null if start() was never invoked and the
// transport was destroyed or if the app initiated close.
if (connCallback_) {
if (!useSplitConnectionCallbacks_) {
processConnectionEndError(cancelCode);
} else {
processConnectionEndErrorSplitCallbacks(cancelCode);
}
}
// can't invoke connection callbacks any more.
resetConnectionCallbacks();
@@ -2706,13 +2700,6 @@ void QuicTransportBase::setSupportedVersions(
conn_->supportedVersions = versions;
}
void QuicTransportBase::setConnectionCallback(ConnectionCallback* callback) {
if (!connCallback_) {
connCallback_ = CallbackDispatcher::make();
}
connCallback_->setConnectionCallback(CHECK_NOTNULL(callback));
}
void QuicTransportBase::setConnectionSetupCallback(
ConnectionSetupCallback* callback) {
if (!connCallback_) {

17
quic/api/QuicTransportBase.h
View File

@@ -38,8 +38,7 @@ class QuicTransportBase : public QuicSocket, QuicStreamPrioritiesObserver {
public:
QuicTransportBase(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> socket,
bool useSplitConnectionCallbacks = false);
std::unique_ptr<folly::AsyncUDPSocket> socket);
~QuicTransportBase() override;
@@ -225,8 +224,6 @@ class QuicTransportBase : public QuicSocket, QuicStreamPrioritiesObserver {
virtual void setSupportedVersions(const std::vector<QuicVersion>& versions);
void setConnectionCallback(ConnectionCallback* callback) final;
void setConnectionSetupCallback(ConnectionSetupCallback* callback) final;
void setConnectionCallbackNew(ConnectionCallbackNew* callback) final;
@@ -862,7 +859,8 @@ class QuicTransportBase : public QuicSocket, QuicStreamPrioritiesObserver {
const std::pair<QuicErrorCode, folly::StringPiece>& cancelCode);
class CallbackDispatcher : public folly::DelayedDestruction,
public ConnectionCallback {
public ConnectionSetupCallback,
public ConnectionCallbackNew {
public:
using UniquePtr = std::unique_ptr<CallbackDispatcher, Destructor>;
@@ -940,10 +938,6 @@ class QuicTransportBase : public QuicSocket, QuicStreamPrioritiesObserver {
}
// Callback setters.
void setConnectionCallback(ConnectionCallback* callback) {
connSetupCallback_ = callback;
connStreamsCallback_ = callback;
}
void setConnectionSetupCallback(ConnectionSetupCallback* callback) {
connSetupCallback_ = callback;
}
@@ -1028,11 +1022,6 @@ class QuicTransportBase : public QuicSocket, QuicStreamPrioritiesObserver {
uint64_t qlogRefcnt_{0};
// Temp flag controlling which connection callbacks to use - old single
// callback object or two new split callback objects. Will be removed out once
// mvfst is switched to the new split callbacks eventually.
bool useSplitConnectionCallbacks_{false};
// Priority level threshold for background streams
// If all streams have equal or lower priority to the threshold
// (value >= threshold), the connection is considered to be in backround mode.

1
quic/api/test/MockQuicSocket.h
View File

@@ -112,7 +112,6 @@ class MockQuicSocket : public QuicSocket {
StreamId,
ReadCallback*,
folly::Optional<ApplicationErrorCode> err));
MOCK_METHOD1(setConnectionCallback, void(ConnectionCallback*));
MOCK_METHOD1(setConnectionSetupCallback, void(ConnectionSetupCallback*));
MOCK_METHOD1(setConnectionCallbackNew, void(ConnectionCallbackNew*));
void setEarlyDataAppParamsFunctions(

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

@@ -553,9 +553,8 @@ TEST_F(QuicTransportImplTest, AckTimeoutExpiredWillResetTimeoutFlag) {
}
TEST_F(QuicTransportImplTest, IdleTimeoutExpiredDestroysTransport) {
EXPECT_CALL(connCallback, onConnectionEnd()).WillOnce(Invoke([&]() {
transport = nullptr;
}));
EXPECT_CALL(connSetupCallback, onConnectionSetupError(_))
.WillOnce(Invoke([&](auto) { transport = nullptr; }));
transport->invokeIdleTimeout();
}
@@ -1171,8 +1170,8 @@ TEST_F(QuicTransportImplTest, onNewBidirectionalStreamSetReadCallback) {
TEST_F(QuicTransportImplTest, OnInvalidServerStream) {
EXPECT_CALL(
connCallback,
onConnectionError(IsError(TransportErrorCode::STREAM_STATE_ERROR)));
connSetupCallback,
onConnectionSetupError(IsError(TransportErrorCode::STREAM_STATE_ERROR)));
auto readData = folly::IOBuf::copyBuffer("actual stream data");
StreamId stream1 = 29;
transport->addDataToStream(stream1, StreamBuffer(readData->clone(), 0, true));
@@ -1412,8 +1411,8 @@ TEST_F(QuicTransportImplTest, ConnectionErrorUnhandledException) {
transport->transportConn->oneRttWriteCipher = test::createNoOpAead();
auto stream = transport->createBidirectionalStream().value();
EXPECT_CALL(
connCallback,
onConnectionError(std::make_pair(
connSetupCallback,
onConnectionSetupError(std::make_pair(
QuicErrorCode(TransportErrorCode::INTERNAL_ERROR),
std::string("Well there's your problem"))));
EXPECT_CALL(*socketPtr, write(_, _)).WillOnce(Invoke([](auto&, auto&) {
@@ -2844,9 +2843,8 @@ TEST_F(QuicTransportImplTest, ExceptionInWriteLooperDoesNotCrash) {
transport->addDataToStream(
stream, StreamBuffer(IOBuf::copyBuffer("hello"), 0, false));
EXPECT_CALL(*socketPtr, write(_, _)).WillOnce(SetErrnoAndReturn(EBADF, -1));
EXPECT_CALL(connCallback, onConnectionError(_)).WillOnce(Invoke([&](auto) {
transport.reset();
}));
EXPECT_CALL(connSetupCallback, onConnectionSetupError(_))
.WillOnce(Invoke([&](auto) { transport.reset(); }));
transport->writeLooper()->runLoopCallback();
}

2
quic/client/QuicClientAsyncTransport.cpp
View File

@@ -15,7 +15,7 @@ namespace quic {
QuicClientAsyncTransport::QuicClientAsyncTransport(
const std::shared_ptr<quic::QuicClientTransport>& clientSock) {
setSocket(clientSock);
clientSock->start(this);
clientSock->start(this, this);
}
void QuicClientAsyncTransport::onNewBidirectionalStream(

3
quic/client/QuicClientAsyncTransport.h
View File

@@ -17,7 +17,8 @@ namespace quic {
* for experiments with QUIC in code using folly::AsyncSockets.
*/
class QuicClientAsyncTransport : public QuicStreamAsyncTransport,
public QuicSocket::ConnectionCallback {
public QuicSocket::ConnectionSetupCallback,
public QuicSocket::ConnectionCallbackNew {
public:
using UniquePtr = std::unique_ptr<
QuicClientAsyncTransport,

28
quic/client/QuicClientTransport.cpp
View File

@@ -38,14 +38,12 @@ QuicClientTransport::QuicClientTransport(
std::unique_ptr<folly::AsyncUDPSocket> socket,
std::shared_ptr<ClientHandshakeFactory> handshakeFactory,
size_t connectionIdSize,
PacketNum startingPacketNum,
bool useSplitConnectionCallbacks)
PacketNum startingPacketNum)
: QuicClientTransport(
evb,
std::move(socket),
std::move(handshakeFactory),
connectionIdSize,
useSplitConnectionCallbacks) {
connectionIdSize) {
conn_->ackStates = AckStates(startingPacketNum);
}
@@ -53,9 +51,8 @@ QuicClientTransport::QuicClientTransport(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> socket,
std::shared_ptr<ClientHandshakeFactory> handshakeFactory,
size_t connectionIdSize,
bool useSplitConnectionCallbacks)
: QuicTransportBase(evb, std::move(socket), useSplitConnectionCallbacks),
size_t connectionIdSize)
: QuicTransportBase(evb, std::move(socket)),
happyEyeballsConnAttemptDelayTimeout_(this) {
DCHECK(handshakeFactory);
auto tempConn =
@@ -1494,20 +1491,9 @@ void QuicClientTransport::
runOnEvbAsync([&](auto) { markZeroRttPacketsLost(*conn_, markPacketLoss); });
}
void QuicClientTransport::start(ConnectionCallback* cb) {
startBase(cb, nullptr, nullptr);
}
void QuicClientTransport::start(
ConnectionSetupCallback* connSetupCb,
ConnectionCallbackNew* connCb) {
startBase(nullptr, connSetupCb, connCb);
}
void QuicClientTransport::startBase(
ConnectionCallback* cb,
ConnectionSetupCallback* connSetupCb,
ConnectionCallbackNew* connCb) {
if (happyEyeballsEnabled_) {
// TODO Supply v4 delay amount from somewhere when we want to tune this
startHappyEyeballs(
@@ -1528,12 +1514,10 @@ void QuicClientTransport::startBase(
if (conn_->qLogger) {
conn_->qLogger->addTransportStateUpdate(kStart);
}
if (cb) {
setConnectionCallback(cb);
} else {
setConnectionSetupCallback(connSetupCb);
setConnectionCallbackNew(connCb);
}
clientConn_->pendingOneRttData.reserve(
conn_->transportSettings.maxPacketsToBuffer);
try {

25
quic/client/QuicClientTransport.h
View File

@@ -31,8 +31,7 @@ class QuicClientTransport
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> socket,
std::shared_ptr<ClientHandshakeFactory> handshakeFactory,
size_t connectionIdSize = 0,
bool useSplitConnectionCallbacks = false);
size_t connectionIdSize = 0);
// Testing only API:
QuicClientTransport(
@@ -40,8 +39,7 @@ class QuicClientTransport
std::unique_ptr<folly::AsyncUDPSocket> socket,
std::shared_ptr<ClientHandshakeFactory> handshakeFactory,
size_t connectionIdSize,
PacketNum startingPacketNum,
bool useSplitConnectionCallbacks = false);
PacketNum startingPacketNum);
~QuicClientTransport() override;
@@ -60,14 +58,9 @@ class QuicClientTransport
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock,
std::shared_ptr<ClientHandshakeFactory> handshakeFactory,
size_t connectionIdSize = 0,
bool useSplitConnectionCallbacks = false) {
size_t connectionIdSize = 0) {
auto client = std::make_shared<TransportType>(
evb,
std::move(sock),
std::move(handshakeFactory),
connectionIdSize,
useSplitConnectionCallbacks);
evb, std::move(sock), std::move(handshakeFactory), connectionIdSize);
client->setSelfOwning();
return client;
}
@@ -95,11 +88,6 @@ class QuicClientTransport
/**
* Starts the connection.
*/
virtual void start(ConnectionCallback* cb);
/**
* Starts the connection with split callbacks.
*/
virtual void start(
ConnectionSetupCallback* connSetupCb,
ConnectionCallbackNew* connCb);
@@ -239,11 +227,6 @@ class QuicClientTransport
*/
void maybeSendTransportKnobs();
void startBase(
ConnectionCallback* cb,
ConnectionSetupCallback* connSetupCb,
ConnectionCallbackNew* connStreamsCb);
bool replaySafeNotified_{false};
// Set it QuicClientTransport is in a self owning mode. This will be cleaned
// up when the caller invokes a terminal call to the transport.

3
quic/client/connector/QuicConnector.cpp
View File

@@ -64,8 +64,7 @@ void QuicConnector::connect(
.setCertificateVerifier(std::move(verifier))
.setPskCache(std::move(quicPskCache))
.build(),
0, /* connectionIdSize */
true /* useSplitConnectionCallbacks */);
0 /* connectionIdSize */);
quicClient_->setHostname(sni.value_or(connectAddr.getAddressStr()));
quicClient_->addNewPeerAddress(connectAddr);
if (localAddr.hasValue()) {

15
quic/fizz/client/test/QuicClientTransportTest.cpp
View File

@@ -385,7 +385,7 @@ TEST_P(QuicClientTransportIntegrationTest, TLSAlert) {
auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
client->getNonConstConn().qLogger = qLogger;
EXPECT_CALL(clientConnCallback, onConnectionError(_))
EXPECT_CALL(clientConnSetupCallback, onConnectionSetupError(_))
.WillOnce(Invoke([&](const auto& errorCode) {
LOG(ERROR) << "error: " << errorCode.second;
const TransportErrorCode* transportError =
@@ -411,7 +411,7 @@ TEST_P(QuicClientTransportIntegrationTest, BadServerTest) {
auto tp = client->getTransportSettings();
tp.maxNumPTOs = 4;
client->setTransportSettings(tp);
EXPECT_CALL(clientConnCallback, onConnectionError(_))
EXPECT_CALL(clientConnSetupCallback, onConnectionSetupError(_))
.WillOnce(Invoke([&](const auto& errorCode) {
LOG(ERROR) << "error: " << errorCode.second;
const LocalErrorCode* localError = errorCode.first.asLocalErrorCode();
@@ -991,7 +991,7 @@ TEST_F(QuicClientTransportTest, CloseSocketOnWriteError) {
client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_FALSE(client->isClosed());
EXPECT_CALL(clientConnCallback, onConnectionError(_));
EXPECT_CALL(clientConnSetupCallback, onConnectionSetupError(_));
eventbase_->loopOnce();
EXPECT_TRUE(client->isClosed());
}
@@ -1053,7 +1053,8 @@ TEST_F(QuicClientTransportTest, onNetworkSwitchReplaceNoHandshake) {
TEST_F(QuicClientTransportTest, SocketClosedDuringOnTransportReady) {
class ConnectionCallbackThatWritesOnTransportReady
: public QuicSocket::ConnectionCallback {
: public QuicSocket::ConnectionSetupCallback,
public QuicSocket::ConnectionCallbackNew {
public:
explicit ConnectionCallbackThatWritesOnTransportReady(
std::shared_ptr<QuicSocket> socket)
@@ -1105,7 +1106,7 @@ TEST_F(QuicClientTransportTest, SocketClosedDuringOnTransportReady) {
client->addNewPeerAddress(serverAddr);
setupCryptoLayer();
client->start(&callback);
client->start(&callback, &callback);
setConnectionIds();
EXPECT_THROW(recvServerHello(), std::runtime_error);
}
@@ -1113,7 +1114,7 @@ TEST_F(QuicClientTransportTest, SocketClosedDuringOnTransportReady) {
TEST_F(QuicClientTransportTest, NetworkUnreachableIsFatalToConn) {
client->addNewPeerAddress(serverAddr);
setupCryptoLayer();
EXPECT_CALL(clientConnCallback, onConnectionError(_));
EXPECT_CALL(clientConnSetupCallback, onConnectionSetupError(_));
EXPECT_CALL(*sock, write(_, _)).WillOnce(SetErrnoAndReturn(ENETUNREACH, -1));
client->start(&clientConnSetupCallback, &clientConnCallback);
loopForWrites();
@@ -1915,7 +1916,7 @@ class QuicClientTransportHappyEyeballsTest
.WillOnce(SetErrnoAndReturn(EBADF, -1));
EXPECT_CALL(*secondSock, write(secondAddress, _))
.WillOnce(SetErrnoAndReturn(EBADF, -1));
EXPECT_CALL(clientConnCallback, onConnectionError(_));
EXPECT_CALL(clientConnSetupCallback, onConnectionSetupError(_));
client->lossTimeout().cancelTimeout();
client->lossTimeout().timeoutExpired();

5
quic/samples/echo/EchoClient.h
View File

@@ -26,7 +26,8 @@
namespace quic {
namespace samples {
class EchoClient : public quic::QuicSocket::ConnectionCallback,
class EchoClient : public quic::QuicSocket::ConnectionSetupCallback,
public quic::QuicSocket::ConnectionCallbackNew,
public quic::QuicSocket::ReadCallback,
public quic::QuicSocket::WriteCallback {
public:
@@ -134,7 +135,7 @@ class EchoClient : public quic::QuicSocket::ConnectionCallback,
std::make_shared<LogQuicStats>("client"));
LOG(INFO) << "EchoClient connecting to " << addr.describe();
quicClient_->start(this);
quicClient_->start(this, this);
});
startDone_.wait();

55
quic/server/QuicServerTransport.cpp
View File

@@ -20,22 +20,6 @@
namespace quic {
QuicServerTransport::QuicServerTransport(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock,
ConnectionCallback& cb,
std::shared_ptr<const fizz::server::FizzServerContext> ctx,
std::unique_ptr<CryptoFactory> cryptoFactory,
PacketNum startingPacketNum)
: QuicServerTransport(
evb,
std::move(sock),
cb,
std::move(ctx),
std::move(cryptoFactory)) {
conn_->ackStates = AckStates(startingPacketNum);
}
QuicServerTransport::QuicServerTransport(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock,
@@ -54,31 +38,6 @@ QuicServerTransport::QuicServerTransport(
conn_->ackStates = AckStates(startingPacketNum);
}
QuicServerTransport::QuicServerTransport(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock,
ConnectionCallback& cb,
std::shared_ptr<const fizz::server::FizzServerContext> ctx,
std::unique_ptr<CryptoFactory> cryptoFactory)
: QuicTransportBase(
evb,
std::move(sock),
false /* useSplitConnectionCallbacks */),
ctx_(std::move(ctx)) {
auto tempConn = std::make_unique<QuicServerConnectionState>(
FizzServerQuicHandshakeContext::Builder()
.setFizzServerContext(ctx_)
.setCryptoFactory(std::move(cryptoFactory))
.build());
tempConn->serverAddr = socket_->address();
serverConn_ = tempConn.get();
conn_.reset(tempConn.release());
conn_->observers = observers_;
setConnectionCallback(&cb);
registerAllTransportKnobParamHandlers();
}
QuicServerTransport::QuicServerTransport(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock,
@@ -86,11 +45,7 @@ QuicServerTransport::QuicServerTransport(
ConnectionCallbackNew* connStreamsCb,
std::shared_ptr<const fizz::server::FizzServerContext> ctx,
std::unique_ptr<CryptoFactory> cryptoFactory)
: QuicTransportBase(
evb,
std::move(sock),
true /* useSplitConnectionCallbacks */),
ctx_(std::move(ctx)) {
: QuicTransportBase(evb, std::move(sock)), ctx_(std::move(ctx)) {
auto tempConn = std::make_unique<QuicServerConnectionState>(
FizzServerQuicHandshakeContext::Builder()
.setFizzServerContext(ctx_)
@@ -118,14 +73,6 @@ QuicServerTransport::~QuicServerTransport() {
false);
}
QuicServerTransport::Ptr QuicServerTransport::make(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock,
ConnectionCallback& cb,
std::shared_ptr<const fizz::server::FizzServerContext> ctx) {
return std::make_shared<QuicServerTransport>(evb, std::move(sock), cb, ctx);
}
QuicServerTransport::Ptr QuicServerTransport::make(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock,

21
quic/server/QuicServerTransport.h
View File

@@ -58,12 +58,6 @@ class QuicServerTransport
virtual void onHandshakeUnfinished() noexcept = 0;
};
static QuicServerTransport::Ptr make(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock,
ConnectionCallback& cb,
std::shared_ptr<const fizz::server::FizzServerContext> ctx);
static QuicServerTransport::Ptr make(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock,
@@ -71,13 +65,6 @@ class QuicServerTransport
ConnectionCallbackNew* connStreamsCb,
std::shared_ptr<const fizz::server::FizzServerContext> ctx);
QuicServerTransport(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock,
ConnectionCallback& cb,
std::shared_ptr<const fizz::server::FizzServerContext> ctx,
std::unique_ptr<CryptoFactory> cryptoFactory = nullptr);
QuicServerTransport(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock,
@@ -87,14 +74,6 @@ class QuicServerTransport
std::unique_ptr<CryptoFactory> cryptoFactory = nullptr);
// Testing only API:
QuicServerTransport(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock,
ConnectionCallback& cb,
std::shared_ptr<const fizz::server::FizzServerContext> ctx,
std::unique_ptr<CryptoFactory> cryptoFactory,
PacketNum startingPacketNum);
QuicServerTransport(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock,

4
quic/server/async_tran/QuicAsyncTransportAcceptor.cpp
View File

@@ -30,8 +30,8 @@ quic::QuicServerTransport::Ptr QuicAsyncTransportAcceptor::make(
CHECK_EQ(evb, evb_);
quic::QuicServerAsyncTransport::UniquePtr asyncWrapper(
new quic::QuicServerAsyncTransport());
auto transport =
quic::QuicServerTransport::make(evb, std::move(sock), *asyncWrapper, ctx);
auto transport = quic::QuicServerTransport::make(
evb, std::move(sock), asyncWrapper.get(), asyncWrapper.get(), ctx);
asyncWrapper->setServerSocket(transport);
wangle::ManagedConnection* managedConnection =
connectionFactory_(std::move(asyncWrapper));

3
quic/server/async_tran/QuicServerAsyncTransport.h
View File

@@ -12,7 +12,8 @@
namespace quic {
class QuicServerAsyncTransport : public QuicStreamAsyncTransport,
public QuicSocket::ConnectionCallback {
public QuicSocket::ConnectionSetupCallback,
public QuicSocket::ConnectionCallbackNew {
public:
using UniquePtr = std::unique_ptr<
QuicServerAsyncTransport,

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

@@ -229,7 +229,8 @@ class TPerfAcceptObserver : public AcceptObserver {
} // namespace
class ServerStreamHandler : public quic::QuicSocket::ConnectionCallback,
class ServerStreamHandler : public quic::QuicSocket::ConnectionSetupCallback,
public quic::QuicSocket::ConnectionCallbackNew,
public quic::QuicSocket::ReadCallback,
public quic::QuicSocket::WriteCallback {
public:
@@ -444,7 +445,7 @@ class TPerfServerTransportFactory : public quic::QuicServerTransportFactory {
auto serverHandler = std::make_unique<ServerStreamHandler>(
evb, blockSize_, numStreams_, maxBytesPerStream_, *sock, dsrEnabled_);
auto transport = quic::QuicServerTransport::make(
evb, std::move(sock), *serverHandler, ctx);
evb, std::move(sock), serverHandler.get(), serverHandler.get(), ctx);
if (!FLAGS_server_qlogger_path.empty()) {
auto qlogger = std::make_shared<TperfQLogger>(
VantagePoint::Server, FLAGS_server_qlogger_path);
@@ -572,7 +573,8 @@ class TPerfServer {
quic::QuicCcpThreadLauncher quicCcpThreadLauncher_;
};
class TPerfClient : public quic::QuicSocket::ConnectionCallback,
class TPerfClient : public quic::QuicSocket::ConnectionSetupCallback,
public quic::QuicSocket::ConnectionCallbackNew,
public quic::QuicSocket::ReadCallback,
public quic::QuicSocket::WriteCallback,
public folly::HHWheelTimer::Callback {
@@ -759,7 +761,7 @@ class TPerfClient : public quic::QuicSocket::ConnectionCallback,
quicClient_->setTransportSettings(settings);
LOG(INFO) << "TPerfClient connecting to " << addr.describe();
quicClient_->start(this);
quicClient_->start(this, this);
eventBase_.loopForever();
}