proxygen::HTTPServer Class Reference

#include <HTTPServer.h>

Classes
struct	IPConfig

Public Types
enum	Protocol : uint8_t { Protocol::HTTP, Protocol::SPDY, Protocol::HTTP2 }

Public Member Functions
	HTTPServer (HTTPServerOptions options)
	~HTTPServer ()
void	bind (std::vector< IPConfig > &&addrs)
void	bind (std::vector< IPConfig > const &addrs)
void	start (std::function< void()> onSuccess=nullptr, std::function< void(std::exception_ptr)> onError=nullptr)
void	stopListening ()
void	stop ()
std::vector< IPConfig >	addresses () const
const std::vector< const folly::AsyncSocketBase * >	getSockets () const
void	setSessionInfoCallback (HTTPSession::InfoCallback *cb)
int	getListenSocket () const
void	updateTLSCredentials ()
void	updateTicketSeeds (wangle::TLSTicketKeySeeds seeds)

Private Attributes
std::shared_ptr< HTTPServerOptions >	options_
folly::EventBase *	mainEventBase_ {nullptr}
std::unique_ptr< SignalHandler >	signalHandler_
std::vector< IPConfig >	addresses_
std::vector< wangle::ServerBootstrap< wangle::DefaultPipeline > >	bootstrap_
HTTPSession::InfoCallback *	sessionInfoCb_ {nullptr}

Detailed Description

HTTPServer based on proxygen http libraries

Definition at line 28 of file HTTPServer.h.

Member Enumeration Documentation

enum proxygen::HTTPServer::Protocol : uint8_t

strong

For each IP you can specify HTTP protocol to use. You can use plain old HTTP/1.1 protocol or SPDY/3.1 for now.

Enumerator
HTTP
SPDY
HTTP2

Definition at line 34 of file HTTPServer.h.

                     : uint8_t {
    HTTP,
    SPDY,
    HTTP2,
  };

Constructor & Destructor Documentation

proxygen::HTTPServer::HTTPServer ( HTTPServerOptions  options )

explicit

Create a new HTTPServer

Definition at line 59 of file HTTPServer.cpp.

References options_.

                                               :
    options_(std::make_shared<HTTPServerOptions>(std::move(options))) {

  // Insert a filter to fail all the CONNECT request, if required
  if (!options_->supportsConnect) {
    options_->handlerFactories.insert(
        options_->handlerFactories.begin(),
        std::make_unique<RejectConnectFilterFactory>());
  }

  // Add Content Compression filter (gzip), if needed. Should be
  // final filter
  if (options_->enableContentCompression) {
    options_->handlerFactories.insert(
        options_->handlerFactories.begin(),
        std::make_unique<ZlibServerFilterFactory>(
          options_->contentCompressionLevel,
          options_->contentCompressionMinimumSize,
          options_->contentCompressionTypes));
  }
}

proxygen::HTTPServer::~HTTPServer

(

)

Definition at line 81 of file HTTPServer.cpp.

References mainEventBase_.

                        {
  CHECK(!mainEventBase_) << "Forgot to stop() server?";
}

Member Function Documentation

std::vector<IPConfig> proxygen::HTTPServer::addresses ( ) const

inline

Get the list of addresses server is listening on. Empty if sockets are not bound yet.

Definition at line 139 of file HTTPServer.h.

References addresses_, and getSockets().

Referenced by TEST().

                                        {
    return addresses_;
  }

void proxygen::HTTPServer::bind

(

std::vector< IPConfig > &&

addrs

)

Configure server to bind to the following addresses.

Actual bind happens in start function.

Can be called from any thread.

Definition at line 85 of file HTTPServer.cpp.

References addresses_, and folly::gen::move.

Referenced by main().

                                                 {
  addresses_ = std::move(addrs);
}

void proxygen::HTTPServer::bind

(

std::vector< IPConfig > const &

addrs

)

Definition at line 89 of file HTTPServer.cpp.

References addresses_.

                                                      {
  addresses_ = addrs;
}

int proxygen::HTTPServer::getListenSocket

(

)

const

Returns a file descriptor associated with the listening socket

Definition at line 224 of file HTTPServer.cpp.

References bootstrap_, and folly::AsyncServerSocket::getSockets().

Referenced by setSessionInfoCallback(), and TEST().

                                      {
  if (bootstrap_.size() == 0) {
    return -1;
  }

  auto& bootstrapSockets = bootstrap_[0].getSockets();
  if (bootstrapSockets.size() == 0) {
    return -1;
  }

  auto serverSocket =
      std::dynamic_pointer_cast<folly::AsyncServerSocket>(bootstrapSockets[0]);
  auto socketFds = serverSocket->getSockets();
  if (socketFds.size() == 0) {
    return -1;
  }

  return socketFds[0];
}

const std::vector< const folly::AsyncSocketBase * > proxygen::HTTPServer::getSockets

(

)

const

Get the sockets the server is currently bound to.

Definition at line 211 of file HTTPServer.cpp.

References bootstrap_, FOR_EACH_RANGE, and i.

Referenced by addresses().

                               {

  std::vector<const folly::AsyncSocketBase*> sockets;
  FOR_EACH_RANGE(i, 0, bootstrap_.size()) {
    auto& bootstrapSockets = bootstrap_[i].getSockets();
    FOR_EACH_RANGE(j, 0, bootstrapSockets.size()) {
      sockets.push_back(bootstrapSockets[j].get());
    }
  }

  return sockets;
}

void proxygen::HTTPServer::setSessionInfoCallback ( HTTPSession::InfoCallback *  cb )

inline

Definition at line 148 of file HTTPServer.h.

References getListenSocket(), sessionInfoCb_, updateTicketSeeds(), and updateTLSCredentials().

                                                           {
    sessionInfoCb_ = cb;
  }

void proxygen::HTTPServer::start	(	std::function< void()>	onSuccess = nullptr,
		std::function< void(std::exception_ptr)>	onError = nullptr
	)

Start HTTPServer.

Note this is a blocking call and the current thread will be used to listen for incoming connections. Throws exception if something goes wrong (say somebody else is already listening on that socket).

onSuccess callback will be invoked from the event loop which shows that all the setup was successfully done.

onError callback will be invoked if some errors occurs while starting the server instead of throwing exception.

Definition at line 119 of file HTTPServer.cpp.

References addresses_, bootstrap_, exe, FOR_EACH_RANGE, folly::pushmi::operators::get, i, folly::EventBase::loopForever(), mainEventBase_, proxygen::HTTPServerAcceptor::makeConfig(), folly::gen::move, options_, folly::EventBase::runInLoop(), sessionInfoCb_, signalHandler_, and stop().

Referenced by main().

                                                                    {
  mainEventBase_ = EventBaseManager::get()->getEventBase();

  auto accExe = std::make_shared<IOThreadPoolExecutor>(1);
  auto exe = std::make_shared<IOThreadPoolExecutor>(options_->threads,
    std::make_shared<folly::NamedThreadFactory>("HTTPSrvExec"));
  auto exeObserver = std::make_shared<HandlerCallbacks>(options_);
  // Observer has to be set before bind(), so onServerStart() callbacks run
  exe->addObserver(exeObserver);

  try {
    FOR_EACH_RANGE (i, 0, addresses_.size()) {
      auto codecFactory = addresses_[i].codecFactory;
      auto accConfig = HTTPServerAcceptor::makeConfig(addresses_[i], *options_);
      auto factory = std::make_shared<AcceptorFactory>(
          options_,
          codecFactory,
          accConfig,
          sessionInfoCb_);
      bootstrap_.push_back(
          wangle::ServerBootstrap<wangle::DefaultPipeline>());
      bootstrap_[i].childHandler(factory);
      if (accConfig.enableTCPFastOpen) {
        // We need to do this because wangle's bootstrap has 2 acceptor configs
        // and the socketConfig gets passed to the SocketFactory. The number of
        // configs should really be one, and when that happens, we can remove
        // this code path.
        bootstrap_[i].socketConfig.enableTCPFastOpen = true;
        bootstrap_[i].socketConfig.fastOpenQueueSize =
            accConfig.fastOpenQueueSize;
      }
      bootstrap_[i].group(accExe, exe);
      if (options_->preboundSockets_.size() > 0) {
        bootstrap_[i].bind(std::move(options_->preboundSockets_[i]));
      } else {
        bootstrap_[i].bind(addresses_[i].address);
      }
    }
  } catch (const std::exception& ex) {
    stop();

    if (onError) {
      onError(std::current_exception());
      return;
    }

    throw;
  }

  // Install signal handler if required
  if (!options_->shutdownOn.empty()) {
    signalHandler_ = std::make_unique<SignalHandler>(this);
    signalHandler_->install(options_->shutdownOn);
  }

  // Start the main event loop.
  if (onSuccess) {
    mainEventBase_->runInLoop([onSuccess(std::move(onSuccess))]() {
      // IMPORTANT: Since we may be racing with stop(), we must assume that
      // mainEventBase_ can become null the moment that onSuccess is called,
      // so this **has** to be queued to run from inside loopForever().
        onSuccess();
    });
  }
  mainEventBase_->loopForever();
}

void proxygen::HTTPServer::stop

(

)

Stop HTTPServer.

Can be called from any thread, but only after start() has called onSuccess. Server will stop listening for new connections and will wait for running requests to finish.

TODO: Separate method to do hard shutdown?

Definition at line 193 of file HTTPServer.cpp.

References bootstrap_, mainEventBase_, signalHandler_, stopListening(), and folly::EventBase::terminateLoopSoon().

Referenced by proxygen::SignalHandler::signalReceived(), and start().

                      {
  stopListening();

  for (auto& bootstrap : bootstrap_) {
    bootstrap.join();
  }

  if (signalHandler_) {
    signalHandler_.reset();
  }

  if (mainEventBase_) {
    mainEventBase_->terminateLoopSoon();
    mainEventBase_ = nullptr;
  }
}

void proxygen::HTTPServer::stopListening

(

)

Stop listening on bound ports. (Stop accepting new work). It does not wait for pending work to complete. You must still invoke stop() before destroying the server. You do NOT need to invoke this before calling stop(). This can be called from any thread, and it is idempotent. However, it may only be called after start() has called onSuccess.

Definition at line 187 of file HTTPServer.cpp.

References bootstrap_.

Referenced by stop(), and TEST().

                               {
  for (auto& bootstrap : bootstrap_) {
    bootstrap.stop();
  }
}

void proxygen::HTTPServer::updateTicketSeeds

(

wangle::TLSTicketKeySeeds

seeds

)

Updates ticket seeds for the HTTPServer for all the VIPs.

Definition at line 262 of file HTTPServer.cpp.

References bootstrap_, wangle::TLSTicketKeySeeds::currentSeeds, wangle::Acceptor::getEventBase(), wangle::Acceptor::isSSL(), wangle::TLSTicketKeySeeds::newSeeds, wangle::TLSTicketKeySeeds::oldSeeds, folly::EventBase::runInEventBaseThread(), and wangle::Acceptor::setTLSTicketSecrets().

Referenced by setSessionInfoCallback(), and TEST().

                                                                {
  for (auto& bootstrap : bootstrap_) {
    bootstrap.forEachWorker([&](wangle::Acceptor* acceptor) {
      if (!acceptor || !acceptor->isSSL()) {
        return;
      }
      auto evb = acceptor->getEventBase();
      if (!evb) {
        return;
      }
      evb->runInEventBaseThread([acceptor, seeds] {
        acceptor->setTLSTicketSecrets(
            seeds.oldSeeds, seeds.currentSeeds, seeds.newSeeds);
      });
    });
  }
}

void proxygen::HTTPServer::updateTLSCredentials

(

)

Re-reads the certificate / key pair for all SSL vips on all acceptors

Definition at line 245 of file HTTPServer.cpp.

References bootstrap_, wangle::Acceptor::getEventBase(), wangle::Acceptor::isSSL(), wangle::Acceptor::resetSSLContextConfigs(), and folly::EventBase::runInEventBaseThread().

Referenced by setSessionInfoCallback().

                                      {
  for (auto& bootstrap : bootstrap_) {
    bootstrap.forEachWorker([&](wangle::Acceptor* acceptor) {
      if (!acceptor || !acceptor->isSSL()) {
        return;
      }
      auto evb = acceptor->getEventBase();
      if (!evb) {
        return;
      }
      evb->runInEventBaseThread([acceptor] {
        acceptor->resetSSLContextConfigs();
      });
    });
  }
}

Member Data Documentation

std::vector<IPConfig> proxygen::HTTPServer::addresses_

private

Addresses we are listening on

Definition at line 183 of file HTTPServer.h.

Referenced by addresses(), bind(), and start().

std::vector<wangle::ServerBootstrap<wangle::DefaultPipeline> > proxygen::HTTPServer::bootstrap_

private

Definition at line 184 of file HTTPServer.h.

Referenced by getListenSocket(), getSockets(), start(), stop(), stopListening(), updateTicketSeeds(), and updateTLSCredentials().

folly::EventBase* proxygen::HTTPServer::mainEventBase_ {nullptr}

private

Event base in which we binded server sockets.

Definition at line 173 of file HTTPServer.h.

Referenced by start(), stop(), and ~HTTPServer().

std::shared_ptr<HTTPServerOptions> proxygen::HTTPServer::options_

private

Definition at line 168 of file HTTPServer.h.

Referenced by HTTPServer(), start(), proxygen::HandlerCallbacks::threadStarted(), and proxygen::HandlerCallbacks::threadStopped().

HTTPSession::InfoCallback* proxygen::HTTPServer::sessionInfoCb_ {nullptr}

private

Callback for session create/destruction

Definition at line 189 of file HTTPServer.h.

Referenced by setSessionInfoCallback(), and start().

std::unique_ptr<SignalHandler> proxygen::HTTPServer::signalHandler_

private

Optional signal handlers on which we should shutdown server

Definition at line 178 of file HTTPServer.h.

Referenced by start(), and stop().

---

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

• proxygen/httpserver/HTTPServer.h
• proxygen/httpserver/HTTPServer.cpp