BootstrapTest.cpp File Reference

#include "wangle/bootstrap/ServerBootstrap.h"
#include "wangle/bootstrap/ClientBootstrap.h"
#include "wangle/channel/Handler.h"
#include <glog/logging.h>
#include <gtest/gtest.h>
#include <boost/thread.hpp>
#include <folly/String.h>
#include <folly/experimental/TestUtil.h>

Go to the source code of this file.

Classes
class	TestClientPipelineFactory
class	TestPipelineFactory
class	TestAcceptor
class	TestAcceptorFactory
class	TestHandlerPipeline
class	TestHandlerPipelineFactory< HandlerPipeline >
class	TestUDPPipeline

Typedefs
typedef Pipeline< IOBufQueue &, std::unique_ptr< IOBuf > >	BytesPipeline
typedef ServerBootstrap< BytesPipeline >	TestServer
typedef ClientBootstrap< BytesPipeline >	TestClient

Functions
	TEST (Bootstrap, Basic)
	TEST (Bootstrap, ServerWithPipeline)
	TEST (Bootstrap, ServerWithChildHandler)
	TEST (Bootstrap, ClientServerTest)
	TEST (Bootstrap, ClientConnectionManagerTest)
	TEST (Bootstrap, ServerAcceptGroupTest)
	TEST (Bootstrap, ServerAcceptGroup2Test)
	TEST (Bootstrap, SharedThreadPool)
	TEST (Bootstrap, ExistingSocket)
	TEST (Bootstrap, LoadBalanceHandler)
	TEST (Bootstrap, UDP)
	TEST (Bootstrap, UDPClientServerTest)
	TEST (Bootstrap, UnixServer)
	TEST (Bootstrap, ServerBindFailure)

Variables
std::atomic< int >	connections {0}

Typedef Documentation

typedef Pipeline<IOBufQueue&, std::unique_ptr<IOBuf> > BytesPipeline

Definition at line 30 of file BootstrapTest.cpp.

typedef ClientBootstrap<BytesPipeline> TestClient

Definition at line 33 of file BootstrapTest.cpp.

typedef ServerBootstrap<BytesPipeline> TestServer

Definition at line 32 of file BootstrapTest.cpp.

Function Documentation

TEST	(	Bootstrap	,
		Basic
	)

Definition at line 87 of file BootstrapTest.cpp.

                       {
  TestServer server;
  TestClient client;
}

TEST	(	Bootstrap	,
		ServerWithPipeline
	)

Definition at line 92 of file BootstrapTest.cpp.

                                    {
  TestServer server;
  server.childPipeline(std::make_shared<TestPipelineFactory>());
  server.bind(0);
  server.stop();
}

TEST	(	Bootstrap	,
		ServerWithChildHandler
	)

Definition at line 99 of file BootstrapTest.cpp.

                                        {
  TestServer server;
  server.childHandler(std::make_shared<TestAcceptorFactory>());
  server.bind(0);
  server.stop();
}

TEST	(	Bootstrap	,
		ClientServerTest
	)

Definition at line 106 of file BootstrapTest.cpp.

References wangle::ClientBootstrap< Pipeline >::connect(), EXPECT_EQ, folly::EventBaseManager::get(), TestServer::getAddress(), folly::EventBaseManager::getEventBase(), and wangle::BaseClientBootstrap< P >::pipelineFactory().

                                  {
  TestServer server;
  auto factory = std::make_shared<TestPipelineFactory>();
  server.childPipeline(factory);
  server.bind(0);
  auto base = EventBaseManager::get()->getEventBase();

  SocketAddress address;
  server.getSockets()[0]->getAddress(&address);

  TestClient client;
  client.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
  client.connect(address);
  base->loop();
  server.stop();
  server.join();

  EXPECT_EQ(factory->pipelines, 1);
}

TEST	(	Bootstrap	,
		ClientConnectionManagerTest
	)

Definition at line 126 of file BootstrapTest.cpp.

References wangle::ClientBootstrap< Pipeline >::connect(), EXPECT_EQ, folly::EventBaseManager::get(), TestServer::getAddress(), folly::EventBaseManager::getEventBase(), and wangle::BaseClientBootstrap< P >::pipelineFactory().

                                             {
  // Create a single IO thread, and verify that
  // client connections are pooled properly

  TestServer server;
  auto factory = std::make_shared<TestPipelineFactory>();
  server.childPipeline(factory);
  server.group(std::make_shared<IOThreadPoolExecutor>(1));
  server.bind(0);
  auto base = EventBaseManager::get()->getEventBase();

  SocketAddress address;
  server.getSockets()[0]->getAddress(&address);

  TestClient client;
  client.pipelineFactory(std::make_shared<TestClientPipelineFactory>());

  client.connect(address);

  TestClient client2;
  client2.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
  client2.connect(address);

  base->loop();
  server.stop();
  server.join();

  EXPECT_EQ(factory->pipelines, 2);
}

TEST	(	Bootstrap	,
		ServerAcceptGroupTest
	)

Definition at line 156 of file BootstrapTest.cpp.

References wangle::ClientBootstrap< Pipeline >::connect(), EXPECT_EQ, folly::EventBaseManager::get(), TestServer::getAddress(), folly::EventBaseManager::getEventBase(), folly::EventBase::loop(), and wangle::BaseClientBootstrap< P >::pipelineFactory().

                                       {
  // Verify that server is using the accept IO group

  TestServer server;
  auto factory = std::make_shared<TestPipelineFactory>();
  server.childPipeline(factory);
  server.group(std::make_shared<IOThreadPoolExecutor>(1), nullptr);
  server.bind(0);

  SocketAddress address;
  server.getSockets()[0]->getAddress(&address);

  boost::barrier barrier(2);
  auto thread = std::thread([&](){
    TestClient client;
    client.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
    client.connect(address);
    EventBaseManager::get()->getEventBase()->loop();
    barrier.wait();
  });
  barrier.wait();
  server.stop();
  thread.join();
  server.join();

  EXPECT_EQ(factory->pipelines, 1);
}

TEST	(	Bootstrap	,
		ServerAcceptGroup2Test
	)

Definition at line 184 of file BootstrapTest.cpp.

References wangle::ClientBootstrap< Pipeline >::connect(), EXPECT_EQ, folly::EventBaseManager::get(), TestServer::getAddress(), folly::EventBaseManager::getEventBase(), folly::INFO, folly::EventBase::loop(), folly::AsyncServerSocket::newSocket(), and wangle::BaseClientBootstrap< P >::pipelineFactory().

                                        {
  // Verify that server is using the accept IO group

  // Check if reuse port is supported, if not, don't run this test
  try {
    EventBase base;
    auto serverSocket = AsyncServerSocket::newSocket(&base);
    serverSocket->bind(0);
    serverSocket->listen(0);
    serverSocket->startAccepting();
    serverSocket->setReusePortEnabled(true);
    serverSocket->stopAccepting();
  } catch(...) {
    LOG(INFO) << "Reuse port probably not supported";
    return;
  }

  TestServer server;
  auto factory = std::make_shared<TestPipelineFactory>();
  server.childPipeline(factory);
  server.group(std::make_shared<IOThreadPoolExecutor>(4), nullptr);
  server.bind(0);

  SocketAddress address;
  server.getSockets()[0]->getAddress(&address);

  TestClient client;
  client.pipelineFactory(std::make_shared<TestClientPipelineFactory>());

  client.connect(address);
  EventBaseManager::get()->getEventBase()->loop();

  server.stop();
  server.join();

  EXPECT_EQ(factory->pipelines, 1);
}

TEST	(	Bootstrap	,
		SharedThreadPool
	)

Definition at line 222 of file BootstrapTest.cpp.

References wangle::ClientBootstrap< Pipeline >::connect(), EXPECT_EQ, folly::EventBaseManager::get(), folly::SocketAddress::getAddress(), folly::EventBaseManager::getEventBase(), folly::INFO, folly::EventBase::loop(), folly::AsyncServerSocket::newSocket(), and wangle::BaseClientBootstrap< P >::pipelineFactory().

                                  {
  // Check if reuse port is supported, if not, don't run this test
  try {
    EventBase base;
    auto serverSocket = AsyncServerSocket::newSocket(&base);
    serverSocket->bind(0);
    serverSocket->listen(0);
    serverSocket->startAccepting();
    serverSocket->setReusePortEnabled(true);
    serverSocket->stopAccepting();
  } catch(...) {
    LOG(INFO) << "Reuse port probably not supported";
    return;
  }

  auto pool = std::make_shared<IOThreadPoolExecutor>(2);

  TestServer server;
  auto factory = std::make_shared<TestPipelineFactory>();
  server.childPipeline(factory);
  server.group(pool, pool);

  server.bind(0);

  SocketAddress address;
  server.getSockets()[0]->getAddress(&address);

  TestClient client;
  client.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
  client.connect(address);

  TestClient client2;
  client2.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
  client2.connect(address);

  TestClient client3;
  client3.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
  client3.connect(address);

  TestClient client4;
  client4.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
  client4.connect(address);

  TestClient client5;
  client5.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
  client5.connect(address);

  EventBaseManager::get()->getEventBase()->loop();

  server.stop();
  server.join();

  EXPECT_EQ(factory->pipelines, 5);
}

TEST	(	Bootstrap	,
		ExistingSocket
	)

Definition at line 277 of file BootstrapTest.cpp.

References folly::gen::move, and folly::netops::socket().

                                {
  TestServer server;
  auto factory = std::make_shared<TestPipelineFactory>();
  server.childPipeline(factory);
  folly::AsyncServerSocket::UniquePtr socket(new AsyncServerSocket);
  server.bind(std::move(socket));
}

TEST	(	Bootstrap	,
		LoadBalanceHandler
	)

Definition at line 310 of file BootstrapTest.cpp.

References wangle::ClientBootstrap< Pipeline >::connect(), connections, EXPECT_EQ, folly::EventBaseManager::get(), TestServer::getAddress(), folly::EventBaseManager::getEventBase(), and wangle::BaseClientBootstrap< P >::pipelineFactory().

                                    {
  TestServer server;
  auto factory = std::make_shared<TestPipelineFactory>();
  server.childPipeline(factory);

  auto pipelinefactory =
    std::make_shared<TestHandlerPipelineFactory<TestHandlerPipeline>>();
  server.pipeline(pipelinefactory);
  server.bind(0);
  auto base = EventBaseManager::get()->getEventBase();

  SocketAddress address;
  server.getSockets()[0]->getAddress(&address);

  TestClient client;
  client.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
  client.connect(address);
  base->loop();
  server.stop();
  server.join();

  EXPECT_EQ(factory->pipelines, 1);
  EXPECT_EQ(connections, 1);
}

TEST	(	Bootstrap	,
		UDP
	)

Definition at line 340 of file BootstrapTest.cpp.

                     {
  TestServer server;
  auto factory = std::make_shared<TestPipelineFactory>();
  auto pipelinefactory =
    std::make_shared<TestHandlerPipelineFactory<TestUDPPipeline>>();
  server.pipeline(pipelinefactory);
  server.channelFactory(std::make_shared<AsyncUDPServerSocketFactory>());
  server.bind(0);
}

TEST	(	Bootstrap	,
		UDPClientServerTest
	)

Definition at line 350 of file BootstrapTest.cpp.

References folly::AsyncUDPSocket::bind(), connections, folly::IOBuf::create(), data, EXPECT_EQ, folly::EventBaseManager::get(), TestServer::getAddress(), folly::EventBaseManager::getEventBase(), folly::gen::move, and folly::AsyncUDPSocket::write().

                                     {
  connections = 0;

  TestServer server;
  auto factory = std::make_shared<TestPipelineFactory>();
  auto pipelinefactory =
    std::make_shared<TestHandlerPipelineFactory<TestUDPPipeline>>();
  server.pipeline(pipelinefactory);
  server.channelFactory(std::make_shared<AsyncUDPServerSocketFactory>());
  server.bind(0);

  auto base = EventBaseManager::get()->getEventBase();

  SocketAddress address;
  server.getSockets()[0]->getAddress(&address);

  SocketAddress localhost("::1", 0);
  AsyncUDPSocket client(base);
  client.bind(localhost);
  auto data = IOBuf::create(1);
  data->append(1);
  *(data->writableData()) = 'a';
  client.write(address, std::move(data));
  base->loop();
  server.stop();
  server.join();

  EXPECT_EQ(connections, 1);
}

TEST	(	Bootstrap	,
		UnixServer
	)

Definition at line 380 of file BootstrapTest.cpp.

References wangle::ClientBootstrap< Pipeline >::connect(), EXPECT_EQ, EXPECT_TRUE, folly::EventBaseManager::get(), folly::EventBaseManager::getEventBase(), folly::gen::move, wangle::BaseClientBootstrap< P >::pipelineFactory(), and folly::SocketAddress::setFromPath().

                            {
  TestServer server;
  auto factory = std::make_shared<TestPipelineFactory>();

  folly::test::TemporaryDirectory tmpdir("wangle-bootstrap-test");
  auto socketPath = (tmpdir.path() / "sock").string();

  server.childPipeline(factory);
  SocketAddress address;
  address.setFromPath(socketPath);
  server.bind(address);
  auto base = EventBaseManager::get()->getEventBase();

  TestClient client;
  client.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
  auto pipelineFuture = client.connect(address);
  base->loop();
  server.stop();
  server.join();

  EXPECT_TRUE(std::move(pipelineFuture).get() != nullptr);
  EXPECT_EQ(factory->pipelines, 1);
}

TEST	(	Bootstrap	,
		ServerBindFailure
	)

Definition at line 404 of file BootstrapTest.cpp.

References EXPECT_EQ, FAIL, folly::SocketAddress::getAddress(), and folly::AsyncServerSocket::newSocket().

                                   {
  // Bind to a TCP socket
  EventBase base;
  auto serverSocket = AsyncServerSocket::newSocket(&base);
  serverSocket->bind(0);
  serverSocket->listen(0);

  SocketAddress address;
  serverSocket->getAddress(&address);

  // Now try starting a server using the address we are already listening on
  // This should fail.

  TestServer server;
  auto factory = std::make_shared<TestPipelineFactory>();
  server.childPipeline(factory);
  try {
    server.bind(address);
    FAIL() << "shouldn't be allowed to bind to an in-use address";
  } catch (const std::system_error& ex) {
    EXPECT_EQ(EADDRINUSE, ex.code().value()) << "unexpected error code " <<
      ex.code().value() << ": " << ex.code().message();
  }
}

Variable Documentation

std::atomic<int> connections {0}

Definition at line 285 of file BootstrapTest.cpp.

Referenced by TestHandlerPipeline::read(), TestUDPPipeline::read(), and TEST().