HTTPServerOptions.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2015-present, Facebook, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  LICENSE file in the root directory of this source tree. An additional grant
 *  of patent rights can be found in the PATENTS file in the same directory.
 *
 */
#pragma once

#include <folly/Function.h>
#include <folly/SocketAddress.h>
#include <folly/io/async/AsyncServerSocket.h>
#include <proxygen/httpserver/Filters.h>
#include <proxygen/httpserver/RequestHandlerFactory.h>
#include <signal.h>

namespace proxygen {

class HTTPServerOptions {
 public:
  using NewConnectionFilter =
      folly::Function<void(const folly::AsyncTransportWrapper* /* sock */,
                           const folly::SocketAddress* /* address */,
                           const std::string& /* nextProtocolName */,
                           SecureTransportType /* secureTransportType */,
                           const wangle::TransportInfo& /* tinfo */) const>;

  size_t threads = 1;

  std::vector<std::unique_ptr<RequestHandlerFactory>> handlerFactories;

  std::chrono::milliseconds idleTimeout{60000};

  uint32_t listenBacklog{1024};

  bool h2cEnabled{false};

  std::vector<int> shutdownOn{};

  bool supportsConnect{false};

  size_t initialReceiveWindow{65536};
  size_t receiveStreamWindowSize{65536};
  size_t receiveSessionWindowSize{65536};

  uint32_t maxConcurrentIncomingStreams{100};

  bool enableContentCompression{false};

  uint64_t contentCompressionMinimumSize{1000};

  int contentCompressionLevel{-1};

  bool enableExHeaders{false};

  std::set<std::string> contentCompressionTypes = {
    "application/javascript",
    "application/json",
    "application/x-javascript",
    "application/xhtml+xml",
    "application/xml",
    "application/xml+rss",
    "text/css",
    "text/html",
    "text/javascript",
    "text/plain",
    "text/xml",
  };

  std::vector<folly::AsyncServerSocket::UniquePtr> preboundSockets_;

  void useExistingSocket(folly::AsyncServerSocket::UniquePtr socket) {
    preboundSockets_.push_back(std::move(socket));
  }

  void useExistingSocket(int socketFd) {
    useExistingSockets({socketFd});
  }

  void useExistingSockets(const std::vector<int>& socketFds) {
    folly::AsyncServerSocket::UniquePtr socket(new folly::AsyncServerSocket);

    socket->useExistingSockets(socketFds);
    useExistingSocket(std::move(socket));
  }

  NewConnectionFilter newConnectionFilter;
};
}