StaticServer.cpp File Reference

#include <folly/Memory.h>
#include <folly/executors/GlobalExecutor.h>
#include <folly/executors/CPUThreadPoolExecutor.h>
#include <folly/init/Init.h>
#include <folly/io/async/EventBaseManager.h>
#include <folly/portability/GFlags.h>
#include <folly/portability/Unistd.h>
#include <proxygen/httpserver/HTTPServer.h>
#include <proxygen/httpserver/RequestHandlerFactory.h>
#include "StaticHandler.h"

Go to the source code of this file.

Typedefs
using	Protocol = HTTPServer::Protocol

Functions
	DEFINE_int32 (http_port, 11000,"Port to listen on with HTTP protocol")
	DEFINE_int32 (h2_port, 11002,"Port to listen on with HTTP/2 protocol")
	DEFINE_string (ip,"localhost","IP/Hostname to bind to")
	DEFINE_int32 (threads, 0,"Number of threads to listen on. Numbers <= 0 ""will use the number of cores on this machine.")
int	main (int argc, char *argv[])

Typedef Documentation

using Protocol = HTTPServer::Protocol

Definition at line 30 of file StaticServer.cpp.

Function Documentation

DEFINE_int32	(	http_port	,
		11000	,
		"Port to listen on with HTTP protocol"
	)

DEFINE_int32	(	h2_port	,
		11002	,
		"Port to listen on with HTTP/2 protocol"
	)

DEFINE_int32	(	threads	,
		0	,
		"Number of threads to listen on. Numbers <= 0 ""will use the number of cores on this machine."
	)

DEFINE_string	(	ip	,
		"localhost"	,
		"IP/Hostname to bind to"
	)

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 53 of file StaticServer.cpp.

References proxygen::RequestHandlerChain::addThen(), proxygen::HTTPServer::bind(), proxygen::HTTPServerOptions::enableContentCompression, proxygen::HTTPServerOptions::h2cEnabled, proxygen::HTTPServerOptions::handlerFactories, proxygen::HTTPServerOptions::idleTimeout, folly::init(), folly::gen::move, folly::setCPUExecutor(), proxygen::HTTPServerOptions::shutdownOn, proxygen::HTTPServer::start(), folly::pushmi::detail::t, and proxygen::HTTPServerOptions::threads.

                                 {
  folly::init(&argc, &argv, true);

  std::vector<HTTPServer::IPConfig> IPs = {
    {SocketAddress(FLAGS_ip, FLAGS_http_port, true), Protocol::HTTP},
    {SocketAddress(FLAGS_ip, FLAGS_h2_port, true), Protocol::HTTP2},
  };

  if (FLAGS_threads <= 0) {
    FLAGS_threads = sysconf(_SC_NPROCESSORS_ONLN);
    CHECK_GT(FLAGS_threads, 0);
  }

  HTTPServerOptions options;
  options.threads = static_cast<size_t>(FLAGS_threads);
  options.idleTimeout = std::chrono::milliseconds(60000);
  options.shutdownOn = {SIGINT, SIGTERM};
  options.enableContentCompression = false;
  options.handlerFactories = RequestHandlerChain()
      .addThen<StaticHandlerFactory>()
      .build();
  options.h2cEnabled = true;

  auto diskIOThreadPool = std::make_shared<folly::CPUThreadPoolExecutor>(
    FLAGS_threads,
    std::make_shared<folly::NamedThreadFactory>("StaticDiskIOThread"));
  folly::setCPUExecutor(diskIOThreadPool);

  HTTPServer server(std::move(options));
  server.bind(IPs);

  // Start HTTPServer mainloop in a separate thread
  std::thread t([&] () {
    server.start();
  });

  t.join();
  return 0;
}