Commit 2586be5b authored by Mingtao Yang's avatar Mingtao Yang Committed by Facebook GitHub Bot

Deprecate AsyncTransportWrapper

Summary:
All implementations of transports in practice were all AsyncTransportWrappers
(AsyncSocket, AsyncSSLSocket, AsyncFizzBase, etc.).

AsyncTransportWrapper was confusing. The only additional functionality that
it provided was the ability to query underlying transports, a piece of
functionality which makes just as much sense on AsyncTransport.

The simplified model:

"AsyncTransport deals with bidirectional I/O. It is both an AsyncReader, and
an AsyncWriter. It may be nested."

This diff changes AsyncTransportWrapper usages in folly to refer to
AsyncTransport, and aliases AsyncTransportWrapper for compatibility.

Reviewed By: yfeldblum

Differential Revision: D21915048

fbshipit-source-id: 741fad91b8f7c8080f942168f5513b12602cfe9a
parent 0e32d9f4
......@@ -368,7 +368,7 @@ bool AsyncSSLSocket::good() const {
sslState_ == STATE_UNINIT));
}
// The AsyncTransportWrapper definition of 'good' states that the transport is
// The AsyncTransport definition of 'good' states that the transport is
// ready to perform reads and writes, so sslState_ == UNINIT must report !good.
// connecting can be true when the sslState_ == UNINIT because the AsyncSocket
// is connected but we haven't initiated the call to SSL_connect.
......
......@@ -320,7 +320,7 @@ class AsyncSSLSocket : public virtual AsyncSocket {
* the flag should be reset.
*/
// Inherit AsyncTransportWrapper methods from AsyncSocket except the
// Inherit AsyncTransport methods from AsyncSocket except the
// following.
// See the documentation in AsyncTransport.h
// TODO: implement graceful shutdown in close()
......
......@@ -73,7 +73,7 @@ namespace folly {
#define SO_NO_TSOCKS 201
#endif
class AsyncSocket : public AsyncTransportWrapper {
class AsyncSocket : public AsyncTransport {
public:
using UniquePtr = std::unique_ptr<AsyncSocket, Destructor>;
......
This diff is collapsed.
......@@ -21,31 +21,30 @@
namespace folly {
/**
* Convenience class so that AsyncTransportWrapper can be decorated without
* Convenience class so that AsyncTransport can be decorated without
* having to redefine every single method.
*/
template <class T>
class DecoratedAsyncTransportWrapper : public folly::AsyncTransportWrapper {
class DecoratedAsyncTransportWrapper : public folly::AsyncTransport {
public:
explicit DecoratedAsyncTransportWrapper(typename T::UniquePtr transport)
: transport_(std::move(transport)) {}
const AsyncTransportWrapper* getWrappedTransport() const override {
const AsyncTransport* getWrappedTransport() const override {
return transport_.get();
}
// folly::AsyncTransportWrapper
// folly::AsyncTransport
ReadCallback* getReadCallback() const override {
return transport_->getReadCallback();
}
void setReadCB(
folly::AsyncTransportWrapper::ReadCallback* callback) override {
void setReadCB(folly::AsyncTransport::ReadCallback* callback) override {
transport_->setReadCB(callback);
}
void write(
folly::AsyncTransportWrapper::WriteCallback* callback,
folly::AsyncTransport::WriteCallback* callback,
const void* buf,
size_t bytes,
folly::WriteFlags flags = folly::WriteFlags::NONE) override {
......@@ -53,14 +52,14 @@ class DecoratedAsyncTransportWrapper : public folly::AsyncTransportWrapper {
}
void writeChain(
folly::AsyncTransportWrapper::WriteCallback* callback,
folly::AsyncTransport::WriteCallback* callback,
std::unique_ptr<folly::IOBuf>&& buf,
folly::WriteFlags flags = folly::WriteFlags::NONE) override {
transport_->writeChain(callback, std::move(buf), flags);
}
void writev(
folly::AsyncTransportWrapper::WriteCallback* callback,
folly::AsyncTransport::WriteCallback* callback,
const iovec* vec,
size_t bytes,
folly::WriteFlags flags = folly::WriteFlags::NONE) override {
......
......@@ -32,7 +32,7 @@ class WriteChainAsyncTransportWrapper
using DecoratedAsyncTransportWrapper<T>::DecoratedAsyncTransportWrapper;
void write(
folly::AsyncTransportWrapper::WriteCallback* callback,
AsyncTransport::WriteCallback* callback,
const void* buf,
size_t bytes,
folly::WriteFlags flags = folly::WriteFlags::NONE) override {
......@@ -41,7 +41,7 @@ class WriteChainAsyncTransportWrapper
}
void writev(
folly::AsyncTransportWrapper::WriteCallback* callback,
AsyncTransport::WriteCallback* callback,
const iovec* vec,
size_t count,
folly::WriteFlags flags = folly::WriteFlags::NONE) override {
......@@ -54,7 +54,7 @@ class WriteChainAsyncTransportWrapper
* derived classes to do that.
*/
void writeChain(
folly::AsyncTransportWrapper::WriteCallback* callback,
AsyncTransport::WriteCallback* callback,
std::unique_ptr<folly::IOBuf>&& buf,
folly::WriteFlags flags = folly::WriteFlags::NONE) override = 0;
};
......
......@@ -805,7 +805,7 @@ TEST(AsyncSSLSocketTest, SSLClientTimeoutTest) {
cerr << "SSLClientTimeoutTest test completed" << endl;
}
class PerLoopReadCallback : public AsyncTransportWrapper::ReadCallback {
class PerLoopReadCallback : public AsyncTransport::ReadCallback {
public:
void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
*bufReturn = buf_.data();
......
......@@ -151,7 +151,7 @@ class SendMsgAncillaryDataCallback : public SendMsgParamsCallbackBase {
std::vector<char> ancillaryData_;
};
class WriteCallbackBase : public AsyncTransportWrapper::WriteCallback {
class WriteCallbackBase : public AsyncTransport::WriteCallback {
public:
explicit WriteCallbackBase(SendMsgParamsCallbackBase* mcb = nullptr)
: state(STATE_WAITING),
......@@ -320,7 +320,7 @@ class WriteCheckTimestampCallback : public WriteCallbackBase {
};
#endif // FOLLY_HAVE_MSG_ERRQUEUE
class ReadCallbackBase : public AsyncTransportWrapper::ReadCallback {
class ReadCallbackBase : public AsyncTransport::ReadCallback {
public:
explicit ReadCallbackBase(WriteCallbackBase* wcb)
: wcb_(wcb), state(STATE_WAITING) {}
......@@ -771,7 +771,7 @@ void sslsocketpair(
AsyncSSLSocket::UniquePtr* serverSock);
class BlockingWriteClient : private AsyncSSLSocket::HandshakeCB,
private AsyncTransportWrapper::WriteCallback {
private AsyncTransport::WriteCallback {
public:
explicit BlockingWriteClient(AsyncSSLSocket::UniquePtr socket)
: socket_(std::move(socket)), bufLen_(2500), iovCount_(2000) {
......@@ -829,7 +829,7 @@ class BlockingWriteClient : private AsyncSSLSocket::HandshakeCB,
};
class BlockingWriteServer : private AsyncSSLSocket::HandshakeCB,
private AsyncTransportWrapper::ReadCallback {
private AsyncTransport::ReadCallback {
public:
explicit BlockingWriteServer(AsyncSSLSocket::UniquePtr socket)
: socket_(std::move(socket)), bufSize_(2500 * 2000), bytesRead_(0) {
......@@ -898,7 +898,7 @@ class BlockingWriteServer : private AsyncSSLSocket::HandshakeCB,
};
class AlpnClient : private AsyncSSLSocket::HandshakeCB,
private AsyncTransportWrapper::WriteCallback {
private AsyncTransport::WriteCallback {
public:
explicit AlpnClient(AsyncSSLSocket::UniquePtr socket)
: nextProto(nullptr), nextProtoLength(0), socket_(std::move(socket)) {
......@@ -932,7 +932,7 @@ class AlpnClient : private AsyncSSLSocket::HandshakeCB,
};
class AlpnServer : private AsyncSSLSocket::HandshakeCB,
private AsyncTransportWrapper::ReadCallback {
private AsyncTransport::ReadCallback {
public:
explicit AlpnServer(AsyncSSLSocket::UniquePtr socket)
: nextProto(nullptr), nextProtoLength(0), socket_(std::move(socket)) {
......@@ -967,7 +967,7 @@ class AlpnServer : private AsyncSSLSocket::HandshakeCB,
};
class RenegotiatingServer : public AsyncSSLSocket::HandshakeCB,
public AsyncTransportWrapper::ReadCallback {
public AsyncTransport::ReadCallback {
public:
explicit RenegotiatingServer(AsyncSSLSocket::UniquePtr socket)
: socket_(std::move(socket)) {
......@@ -1010,7 +1010,7 @@ class RenegotiatingServer : public AsyncSSLSocket::HandshakeCB,
#ifndef OPENSSL_NO_TLSEXT
class SNIClient : private AsyncSSLSocket::HandshakeCB,
private AsyncTransportWrapper::WriteCallback {
private AsyncTransport::WriteCallback {
public:
explicit SNIClient(AsyncSSLSocket::UniquePtr socket)
: serverNameMatch(false), socket_(std::move(socket)) {
......@@ -1042,7 +1042,7 @@ class SNIClient : private AsyncSSLSocket::HandshakeCB,
};
class SNIServer : private AsyncSSLSocket::HandshakeCB,
private AsyncTransportWrapper::ReadCallback {
private AsyncTransport::ReadCallback {
public:
explicit SNIServer(
AsyncSSLSocket::UniquePtr socket,
......@@ -1098,8 +1098,8 @@ class SNIServer : private AsyncSSLSocket::HandshakeCB,
#endif
class SSLClient : public AsyncSocket::ConnectCallback,
public AsyncTransportWrapper::WriteCallback,
public AsyncTransportWrapper::ReadCallback {
public AsyncTransport::WriteCallback,
public AsyncTransport::ReadCallback {
private:
EventBase* eventBase_;
std::shared_ptr<AsyncSSLSocket> sslSocket_;
......@@ -1251,7 +1251,7 @@ class SSLClient : public AsyncSocket::ConnectCallback,
};
class SSLHandshakeBase : public AsyncSSLSocket::HandshakeCB,
private AsyncTransportWrapper::WriteCallback {
private AsyncTransport::WriteCallback {
public:
explicit SSLHandshakeBase(
AsyncSSLSocket::UniquePtr socket,
......
......@@ -56,8 +56,8 @@ struct EvbAndContext {
};
class AttachDetachClient : public AsyncSocket::ConnectCallback,
public AsyncTransportWrapper::WriteCallback,
public AsyncTransportWrapper::ReadCallback {
public AsyncTransport::WriteCallback,
public AsyncTransport::ReadCallback {
private:
// two threads here - we'll create the socket in one, connect
// in the other, and then read/write in the initial one
......
......@@ -55,7 +55,7 @@ class ConnCallback : public folly::AsyncSocket::ConnectCallback {
VoidCallback errorCallback;
};
class WriteCallback : public folly::AsyncTransportWrapper::WriteCallback {
class WriteCallback : public folly::AsyncTransport::WriteCallback {
public:
WriteCallback()
: state(STATE_WAITING),
......@@ -88,7 +88,7 @@ class WriteCallback : public folly::AsyncTransportWrapper::WriteCallback {
VoidCallback errorCallback;
};
class ReadCallback : public folly::AsyncTransportWrapper::ReadCallback {
class ReadCallback : public folly::AsyncTransport::ReadCallback {
public:
explicit ReadCallback(size_t _maxBufferSz = 4096)
: state(STATE_WAITING),
......
......@@ -23,8 +23,8 @@
#include <folly/net/NetworkSocket.h>
class BlockingSocket : public folly::AsyncSocket::ConnectCallback,
public folly::AsyncTransportWrapper::ReadCallback,
public folly::AsyncTransportWrapper::WriteCallback {
public folly::AsyncTransport::ReadCallback,
public folly::AsyncTransport::WriteCallback {
public:
explicit BlockingSocket(folly::NetworkSocket fd)
: sock_(new folly::AsyncSocket(&eventBase_, fd)) {}
......
......@@ -23,7 +23,7 @@
namespace folly {
namespace test {
class MockAsyncTransport : public AsyncTransportWrapper {
class MockAsyncTransport : public AsyncTransport {
public:
MOCK_METHOD1(setReadCB, void(ReadCallback*));
MOCK_CONST_METHOD0(getReadCallback, ReadCallback*());
......@@ -64,7 +64,7 @@ class MockAsyncTransport : public AsyncTransportWrapper {
MOCK_CONST_METHOD0(getRawBytesReceived, size_t());
MOCK_CONST_METHOD0(isEorTrackingEnabled, bool());
MOCK_METHOD1(setEorTracking, void(bool));
MOCK_CONST_METHOD0(getWrappedTransport, AsyncTransportWrapper*());
MOCK_CONST_METHOD0(getWrappedTransport, AsyncTransport*());
MOCK_CONST_METHOD0(isReplaySafe, bool());
MOCK_METHOD1(
setReplaySafetyCallback,
......@@ -80,7 +80,7 @@ class MockReplaySafetyCallback : public AsyncTransport::ReplaySafetyCallback {
}
};
class MockReadCallback : public AsyncTransportWrapper::ReadCallback {
class MockReadCallback : public AsyncTransport::ReadCallback {
public:
MOCK_METHOD2(getReadBuffer, void(void**, size_t*));
......@@ -111,7 +111,7 @@ class MockReadCallback : public AsyncTransportWrapper::ReadCallback {
}
};
class MockWriteCallback : public AsyncTransportWrapper::WriteCallback {
class MockWriteCallback : public AsyncTransport::WriteCallback {
public:
MOCK_METHOD0(writeSuccess_, void());
void writeSuccess() noexcept override {
......
......@@ -25,16 +25,15 @@ namespace folly {
namespace test {
class TestWriteChainAsyncTransportWrapper
: public WriteChainAsyncTransportWrapper<folly::AsyncTransportWrapper> {
: public WriteChainAsyncTransportWrapper<folly::AsyncTransport> {
public:
TestWriteChainAsyncTransportWrapper()
: WriteChainAsyncTransportWrapper<folly::AsyncTransportWrapper>(nullptr) {
}
: WriteChainAsyncTransportWrapper<folly::AsyncTransport>(nullptr) {}
MOCK_METHOD3(
writeChain,
void(
folly::AsyncTransportWrapper::WriteCallback*,
folly::AsyncTransport::WriteCallback*,
std::shared_ptr<folly::IOBuf>,
folly::WriteFlags));
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment