HTTPSessionAcceptor.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 <proxygen/lib/http/codec/HTTPCodecFactory.h>
#include <proxygen/lib/http/codec/SPDYCodec.h>
#include <proxygen/lib/http/session/HTTPDownstreamSession.h>
#include <proxygen/lib/http/session/HTTPErrorPage.h>
#include <proxygen/lib/http/session/SimpleController.h>
#include <proxygen/lib/services/HTTPAcceptor.h>
#include <folly/io/async/AsyncSSLSocket.h>

namespace proxygen {

class HTTPSessionStats;

class HTTPSessionAcceptor:
  public HTTPAcceptor,
  private HTTPSessionBase::InfoCallback {
public:
  explicit HTTPSessionAcceptor(const AcceptorConfiguration& accConfig);
  explicit HTTPSessionAcceptor(const AcceptorConfiguration& accConfig,
                               std::shared_ptr<HTTPCodecFactory> codecFactory);
  ~HTTPSessionAcceptor() override;

  void setDefaultErrorPage(std::unique_ptr<HTTPErrorPage> generator) {
    defaultErrorPage_ = std::move(generator);
  }

  const HTTPErrorPage* getDefaultErrorPage() const {
    return defaultErrorPage_.get();
  }

  void setDiagnosticErrorPage(std::unique_ptr<HTTPErrorPage> generator) {
    diagnosticErrorPage_ = std::move(generator);
  }

  const HTTPErrorPage* getDiagnosticErrorPage() const {
    return diagnosticErrorPage_.get();
  }

  virtual const HTTPErrorPage* getErrorPage(
      const folly::SocketAddress& addr) const;

  void setCodecFactory(std::shared_ptr<HTTPCodecFactory> codecFactory) {
    codecFactory_ = codecFactory;
  }

  std::shared_ptr<HTTPCodecFactory> getCodecFactory() {
    return codecFactory_;
  }

  virtual HTTPTransaction::Handler* newHandler(
    HTTPTransaction& txn, HTTPMessage* msg) noexcept = 0;

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

  virtual bool getHttp2PrioritiesEnabled() {
    return accConfig_.HTTP2PrioritiesEnabled;
  }

protected:
  virtual HTTPSessionController* getController() {
    return &simpleController_;
  }

  HTTPSessionStats* downstreamSessionStats_{nullptr};

  HTTPSession::InfoCallback* getSessionInfoCallback() {
    return sessionInfoCb_ ? sessionInfoCb_ : this;
  }

  // Acceptor methods
  void onNewConnection(
    folly::AsyncTransportWrapper::UniquePtr sock,
    const folly::SocketAddress* address,
    const std::string& nextProtocol,
    wangle::SecureTransportType secureTransportType,
    const wangle::TransportInfo& tinfo) override;

  folly::AsyncSocket::UniquePtr makeNewAsyncSocket(folly::EventBase* base,
                                                   int fd) override {
    return folly::AsyncSocket::UniquePtr(
      new folly::AsyncSocket(base, fd));
  }

  virtual size_t dropIdleConnections(size_t num);

  virtual void onSessionCreationError(ProxygenError /*error*/) {}

 private:
  HTTPSessionAcceptor(const HTTPSessionAcceptor&) = delete;
  HTTPSessionAcceptor& operator=(const HTTPSessionAcceptor&) = delete;

  std::unique_ptr<HTTPErrorPage> defaultErrorPage_;

  std::unique_ptr<HTTPErrorPage> diagnosticErrorPage_;

  std::shared_ptr<HTTPCodecFactory> codecFactory_{};

  SimpleController simpleController_;

  HTTPSession::InfoCallback* sessionInfoCb_{nullptr};

  static const folly::SocketAddress unknownSocketAddress_;
};

} // proxygen