Summary:
In the ConnectTFOTimeout and ConnectTFOFallbackTimeout tests in
AsyncSSLSocketTest.cpp, the client runs for 1ms before timing out and quitting.
It may end up shutting down the server thread before the server has even
received the TCP connect callback. If this happened it would cause the test to
fail, since the server code checked to make sure the callback was invoked.
This diff creates a new ConnectTimeoutCallback server-side callback for these
tests to use, which doesn't care if it gets told about a new connection or not.
Reviewed By: siyengar
Differential Revision:
D3512809
fbshipit-source-id:
ce77fe944fb06a38a84c1458356f161cec7387b3
State state{State::WAITING};
};
State state{State::WAITING};
};
+template <class Cardinality>
MockAsyncTFOSSLSocket::UniquePtr setupSocketWithFallback(
EventBase* evb,
MockAsyncTFOSSLSocket::UniquePtr setupSocketWithFallback(
EventBase* evb,
- const SocketAddress& address) {
+ const SocketAddress& address,
+ Cardinality cardinality) {
// Set up SSL context.
auto sslContext = std::make_shared<SSLContext>();
// Set up SSL context.
auto sslContext = std::make_shared<SSLContext>();
socket->enableTFO();
EXPECT_CALL(*socket, tfoSendMsg(_, _, _))
socket->enableTFO();
EXPECT_CALL(*socket, tfoSendMsg(_, _, _))
.WillOnce(Invoke([&](int fd, struct msghdr*, int) {
sockaddr_storage addr;
auto len = address.getAddress(&addr);
.WillOnce(Invoke([&](int fd, struct msghdr*, int) {
sockaddr_storage addr;
auto len = address.getAddress(&addr);
- auto socket = setupSocketWithFallback(&evb, server.getAddress());
+ auto socket = setupSocketWithFallback(&evb, server.getAddress(), 1);
ConnCallback ccb;
socket->connect(&ccb, server.getAddress(), 30);
ConnCallback ccb;
socket->connect(&ccb, server.getAddress(), 30);
TEST(AsyncSSLSocketTest, ConnectTFOTimeout) {
// Start listening on a local port
TEST(AsyncSSLSocketTest, ConnectTFOTimeout) {
// Start listening on a local port
- WriteCallbackBase writeCallback;
- ReadErrorCallback readCallback(&writeCallback);
- HandshakeCallback handshakeCallback(&readCallback);
- SSLServerAcceptCallback acceptCallback(&handshakeCallback);
+ ConnectTimeoutCallback acceptCallback;
TestSSLServer server(&acceptCallback, true);
// Set up SSL context.
TestSSLServer server(&acceptCallback, true);
// Set up SSL context.
TEST(AsyncSSLSocketTest, ConnectTFOFallbackTimeout) {
// Start listening on a local port
TEST(AsyncSSLSocketTest, ConnectTFOFallbackTimeout) {
// Start listening on a local port
- WriteCallbackBase writeCallback;
- ReadErrorCallback readCallback(&writeCallback);
- HandshakeCallback handshakeCallback(&readCallback);
- SSLServerAcceptCallback acceptCallback(&handshakeCallback);
+ ConnectTimeoutCallback acceptCallback;
TestSSLServer server(&acceptCallback, true);
EventBase evb;
TestSSLServer server(&acceptCallback, true);
EventBase evb;
- auto socket = setupSocketWithFallback(&evb, server.getAddress());
+ auto socket = setupSocketWithFallback(&evb, server.getAddress(), AtMost(1));
ConnCallback ccb;
// Set a short timeout
socket->connect(&ccb, server.getAddress(), 1);
ConnCallback ccb;
// Set a short timeout
socket->connect(&ccb, server.getAddress(), 1);
: wcb_(wcb), state(STATE_WAITING) {}
~ReadCallbackBase() {
: wcb_(wcb), state(STATE_WAITING) {}
~ReadCallbackBase() {
- EXPECT_EQ(state, STATE_SUCCEEDED);
+ EXPECT_EQ(STATE_SUCCEEDED, state);
- EXPECT_EQ(state, STATE_SUCCEEDED);
+ EXPECT_EQ(STATE_SUCCEEDED, state);
state(STATE_WAITING), hcb_(hcb) {}
~SSLServerAcceptCallbackBase() {
state(STATE_WAITING), hcb_(hcb) {}
~SSLServerAcceptCallbackBase() {
- EXPECT_EQ(state, STATE_SUCCEEDED);
+ EXPECT_EQ(STATE_SUCCEEDED, state);
}
void acceptError(const std::exception& ex) noexcept override {
}
void acceptError(const std::exception& ex) noexcept override {
+class ConnectTimeoutCallback : public SSLServerAcceptCallbackBase {
+ public:
+ ConnectTimeoutCallback() : SSLServerAcceptCallbackBase(nullptr) {
+ // We don't care if we get invoked or not.
+ // The client may time out and give up before connAccepted() is even
+ // called.
+ state = STATE_SUCCEEDED;
+ }
+
+ // Functions inherited from TAsyncSSLServerSocket::SSLAcceptCallback
+ void connAccepted(
+ const std::shared_ptr<folly::AsyncSSLSocket>& s) noexcept override {
+ std::cerr << "ConnectTimeoutCallback::connAccepted" << std::endl;
+
+ // Just wait a while before closing the socket, so the client
+ // will time out waiting for the handshake to complete.
+ s->getEventBase()->tryRunAfterDelay([=] { s->close(); }, 100);
+ }
+};
class TestSSLServer {
protected:
class TestSSLServer {
protected: