HTTPUpstreamSession.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/io/async/SSLContext.h>
#include <proxygen/lib/http/session/HTTPSession.h>
#include <proxygen/lib/http/codec/compress/HeaderCodec.h>
#include <proxygen/lib/http/session/HTTPSessionStats.h>

namespace proxygen {

class HTTPSessionStats;
class SPDYStats;

class HTTPUpstreamSession final: public HTTPSession {
 public:
  HTTPUpstreamSession(
      const WheelTimerInstance& timeout,
      folly::AsyncTransportWrapper::UniquePtr&& sock,
      const folly::SocketAddress& localAddr,
      const folly::SocketAddress& peerAddr,
      std::unique_ptr<HTTPCodec> codec,
      const wangle::TransportInfo& tinfo,
      InfoCallback* infoCallback,
      uint8_t maxVirtualPri = 0,
      std::shared_ptr<const PriorityMapFactory> priorityMapFactory =
          std::shared_ptr<const PriorityMapFactory>()) :
    HTTPSession(
        timeout,
        std::move(sock),
        localAddr,
        peerAddr,
        nullptr,
        std::move(codec),
        tinfo,
        infoCallback),
    maxVirtualPriorityLevel_(priorityMapFactory ? 0 : maxVirtualPri),
    priorityMapFactory_(priorityMapFactory) {
    if (sock_) {
      auto asyncSocket = sock_->getUnderlyingTransport<folly::AsyncSocket>();
      if (asyncSocket) {
        asyncSocket->setBufferCallback(this);
      }
    }
    CHECK_EQ(codec_->getTransportDirection(), TransportDirection::UPSTREAM);
  }

  // uses folly::HHWheelTimer instance which is used on client side & thrift
  HTTPUpstreamSession(
      folly::HHWheelTimer* timeout,
      folly::AsyncTransportWrapper::UniquePtr&& sock,
      const folly::SocketAddress& localAddr,
      const folly::SocketAddress& peerAddr,
      std::unique_ptr<HTTPCodec> codec,
      const wangle::TransportInfo& tinfo,
      InfoCallback* infoCallback,
      uint8_t maxVirtualPri = 0,
      std::shared_ptr<const PriorityMapFactory> priorityMapFactory =
          std::shared_ptr<const PriorityMapFactory>()) :
    HTTPUpstreamSession(
        WheelTimerInstance(timeout),
        std::move(sock),
        localAddr,
        peerAddr,
        std::move(codec),
        tinfo,
        infoCallback,
        maxVirtualPri,
        priorityMapFactory) {
  }

  using FilterIteratorFn = std::function<void(HTTPCodecFilter*)>;

  void detachTransactions();

  bool isDetachable(bool checkSocket=true) const override;

  void attachThreadLocals(folly::EventBase* eventBase,
                          folly::SSLContextPtr sslContext,
                          const WheelTimerInstance& timeout,
                          HTTPSessionStats* stats,
                          FilterIteratorFn fn,
                          HeaderCodec::Stats* headerCodecStats,
                          HTTPSessionController* controller) override;

  void detachThreadLocals(bool detachSSLContext=false) override;

  void startNow() override;

  HTTPTransaction* newTransaction(HTTPTransaction::Handler* handler) override;

  bool isReplaySafe() const override;

  bool isReusable() const override;

  bool isClosing() const override;

  void drain() override {
    HTTPSession::drain();
  }

 virtual folly::Optional<const HTTPMessage::HTTPPriority> getHTTPPriority(
     uint8_t level) override {
   if (!priorityAdapter_) {
     return HTTPSession::getHTTPPriority(level);
   }
   return priorityAdapter_->getHTTPPriority(level);
 }

 private:
  ~HTTPUpstreamSession() override;

  void setupOnHeadersComplete(
      HTTPTransaction* /* txn */, HTTPMessage* /* msg */) override {}

  HTTPTransaction::Handler* getTransactionTimeoutHandler(
    HTTPTransaction* txn) override;

  bool allTransactionsStarted() const override;

  bool onNativeProtocolUpgrade(
    HTTPCodec::StreamID streamID, CodecProtocol protocol,
    const std::string& protocolString,
    HTTPMessage& msg) override;

  void maybeAttachSSLContext(folly::SSLContextPtr sslContext) const;
  void maybeDetachSSLContext() const;

  uint8_t maxVirtualPriorityLevel_{0};

  std::shared_ptr<const PriorityMapFactory> priorityMapFactory_;
  std::unique_ptr<PriorityAdapter> priorityAdapter_;
};

} // proxygen