HTTPServer.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 <wangle/ssl/SSLContextConfig.h>
#include <folly/io/async/EventBase.h>
#include <wangle/bootstrap/ServerBootstrap.h>
#include <proxygen/httpserver/HTTPServerOptions.h>
#include <proxygen/lib/http/codec/HTTPCodecFactory.h>
#include <proxygen/lib/http/session/HTTPSession.h>
#include <thread>

namespace proxygen {

class SignalHandler;
class HTTPServerAcceptor;

class HTTPServer final {
 public:
  enum class Protocol: uint8_t {
    HTTP,
    SPDY,
    HTTP2,
  };

  struct IPConfig {
    IPConfig(folly::SocketAddress a,
             Protocol p,
             std::shared_ptr<HTTPCodecFactory> c = nullptr)
        : address(a),
          protocol(p),
          codecFactory(c) {}

    folly::SocketAddress address;
    Protocol protocol;
    std::shared_ptr<HTTPCodecFactory> codecFactory;
    std::vector<wangle::SSLContextConfig> sslConfigs;

    /*
     * Sets the initial ticket seeds to use when starting the HTTPServer.
     * Ticket seeds are used to generate the session ticket encryption keys
     * for ticket resumption. When using session tickets, it is important
     * to change them and keep them updated, see updateTicketSeeds to keep
     * seeds up to date.
     */
    folly::Optional<wangle::TLSTicketKeySeeds> ticketSeeds;

    /*
     * Whether to allow an insecure connection on a secure port.
     * This should be used in very few cases where a HTTP server needs to
     * support insecure and secure connections on the same address.
     */
    bool allowInsecureConnectionsOnSecureServer{false};
    bool enableTCPFastOpen{false};
    uint32_t fastOpenQueueSize{10000};

    /*
     * Determines if this server does strict checking when loading SSL contexts.
     */
    bool strictSSL{true};

    folly::Optional<folly::AsyncSocket::OptionMap> acceptorSocketOptions;
  };

  explicit 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 {
    return addresses_;
  }

  const std::vector<const folly::AsyncSocketBase*> getSockets() const;

  void setSessionInfoCallback(HTTPSession::InfoCallback* cb) {
    sessionInfoCb_ = cb;
  }

  int getListenSocket() const;

  void updateTLSCredentials();

  void updateTicketSeeds(wangle::TLSTicketKeySeeds seeds);

 private:
  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};
};

}