TestServer Class Reference

#include <AsyncSocketTest.h>

Public Member Functions
	TestServer (bool enableTFO=false, int bufSize=-1)
	~TestServer ()
const folly::SocketAddress &	getAddress () const
int	acceptFD (int timeout=50)
std::shared_ptr< BlockingSocket >	accept (int timeout=50)
std::shared_ptr< folly::AsyncSocket >	acceptAsync (folly::EventBase *evb, int timeout=50)
void	verifyConnection (const char *buf, size_t len)

Private Attributes
int	fd_
folly::SocketAddress	address_

Detailed Description

Definition at line 267 of file AsyncSocketTest.h.

Constructor & Destructor Documentation

TestServer::TestServer ( bool  enableTFO = false, int  bufSize = -1  )

inlineexplicit

Definition at line 271 of file AsyncSocketTest.h.

References folly::netops::bind(), folly::AsyncSocketException::INTERNAL_ERROR, folly::netops::listen(), SCOPE_EXIT, folly::netops::setsockopt(), folly::netops::socket(), and folly::detail::tfo_enable().

                                                                : fd_(-1) {
    namespace fsp = folly::portability::sockets;
    fd_ = fsp::socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (fd_ < 0) {
      throw folly::AsyncSocketException(
          folly::AsyncSocketException::INTERNAL_ERROR,
          "failed to create test server socket",
          errno);
    }
    if (fcntl(fd_, F_SETFL, O_NONBLOCK) != 0) {
      throw folly::AsyncSocketException(
          folly::AsyncSocketException::INTERNAL_ERROR,
          "failed to put test server socket in "
          "non-blocking mode",
          errno);
    }
    if (enableTFO) {
#if FOLLY_ALLOW_TFO
      folly::detail::tfo_enable(fd_, 100);
#endif
    }

    struct addrinfo hints, *res;
    memset(&hints, 0, sizeof(hints));
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = AI_PASSIVE;

    if (getaddrinfo(nullptr, "0", &hints, &res)) {
      throw folly::AsyncSocketException(
          folly::AsyncSocketException::INTERNAL_ERROR,
          "Attempted to bind address to socket with "
          "bad getaddrinfo",
          errno);
    }

    SCOPE_EXIT {
      freeaddrinfo(res);
    };

    if (bufSize > 0) {
      setsockopt(fd_, SOL_SOCKET, SO_SNDBUF, &bufSize, sizeof(bufSize));
      setsockopt(fd_, SOL_SOCKET, SO_RCVBUF, &bufSize, sizeof(bufSize));
    }

    if (bind(fd_, res->ai_addr, res->ai_addrlen)) {
      throw folly::AsyncSocketException(
          folly::AsyncSocketException::INTERNAL_ERROR,
          "failed to bind to async server socket for port 10",
          errno);
    }

    if (listen(fd_, 10) != 0) {
      throw folly::AsyncSocketException(
          folly::AsyncSocketException::INTERNAL_ERROR,
          "failed to listen on test server socket",
          errno);
    }

    address_.setFromLocalAddress(fd_);
    // The local address will contain 0.0.0.0.
    // Change it to 127.0.0.1, so it can be used to connect to the server
    address_.setFromIpPort("127.0.0.1", address_.getPort());
  }

TestServer::~TestServer ( )

inline

Definition at line 336 of file AsyncSocketTest.h.

References folly::netops::close().

                {
    if (fd_ != -1) {
      close(fd_);
    }
  }

Member Function Documentation

std::shared_ptr<BlockingSocket> TestServer::accept ( int  timeout = 50 )

inline

Definition at line 375 of file AsyncSocketTest.h.

Referenced by TEST(), and TEST_P().

                                                         {
    int fd = acceptFD(timeout);
    return std::make_shared<BlockingSocket>(fd);
  }

std::shared_ptr<folly::AsyncSocket> TestServer::acceptAsync ( folly::EventBase *  evb, int  timeout = 50  )

inline

Definition at line 380 of file AsyncSocketTest.h.

References folly::AsyncSocket::newSocket().

Referenced by TEST(), and testConnectOptWrite().

                        {
    int fd = acceptFD(timeout);
    return folly::AsyncSocket::newSocket(evb, fd);
  }

int TestServer::acceptFD ( int  timeout = 50 )

inline

Definition at line 347 of file AsyncSocketTest.h.

References folly::netops::accept(), folly::AsyncSocketException::INTERNAL_ERROR, and folly::netops::poll().

Referenced by TEST().

                                 {
    namespace fsp = folly::portability::sockets;
    struct pollfd pfd;
    pfd.fd = fd_;
    pfd.events = POLLIN;
    int ret = poll(&pfd, 1, timeout);
    if (ret == 0) {
      throw folly::AsyncSocketException(
          folly::AsyncSocketException::INTERNAL_ERROR,
          "test server accept() timed out");
    } else if (ret < 0) {
      throw folly::AsyncSocketException(
          folly::AsyncSocketException::INTERNAL_ERROR,
          "test server accept() poll failed",
          errno);
    }

    int acceptedFd = fsp::accept(fd_, nullptr, nullptr);
    if (acceptedFd < 0) {
      throw folly::AsyncSocketException(
          folly::AsyncSocketException::INTERNAL_ERROR,
          "test server accept() failed",
          errno);
    }

    return acceptedFd;
  }

const folly::SocketAddress& TestServer::getAddress ( ) const

inline

Definition at line 343 of file AsyncSocketTest.h.

Referenced by TEST(), TEST_P(), and testConnectOptWrite().

                                               {
    return address_;
  }

void TestServer::verifyConnection ( const char *  buf, size_t  len  )

inline

Accept a connection, read data from it, and verify that it matches the data in the specified buffer.

Definition at line 391 of file AsyncSocketTest.h.

References folly::netops::accept(), uint32_t, and uint8_t.

Referenced by TEST(), and TEST_P().

                                                     {
    // accept a connection
    std::shared_ptr<BlockingSocket> acceptedSocket = accept();
    // read the data and compare it to the specified buffer
    std::unique_ptr<uint8_t[]> readbuf(new uint8_t[len]);
    acceptedSocket->readAll(readbuf.get(), len);
    CHECK_EQ(memcmp(buf, readbuf.get(), len), 0);
    // make sure we get EOF next
    uint32_t bytesRead = acceptedSocket->read(readbuf.get(), len);
    CHECK_EQ(bytesRead, 0);
  }

Member Data Documentation

folly::SocketAddress TestServer::address_

private

Definition at line 405 of file AsyncSocketTest.h.

int TestServer::fd_

private

Definition at line 404 of file AsyncSocketTest.h.

---

The documentation for this class was generated from the following file:

• proxygen/folly/folly/io/async/test/AsyncSocketTest.h