HTTPTransaction.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 <boost/heap/d_ary_heap.hpp>
#include <climits>
#include <folly/Optional.h>
#include <folly/SocketAddress.h>
#include <folly/io/async/AsyncTransport.h>
#include <folly/io/async/DelayedDestructionBase.h>
#include <folly/io/async/HHWheelTimer.h>
#include <iosfwd>
#include <wangle/acceptor/TransportInfo.h>
#include <proxygen/lib/http/HTTPConstants.h>
#include <proxygen/lib/http/HTTPHeaderSize.h>
#include <proxygen/lib/http/HTTPMessage.h>
#include <proxygen/lib/http/ProxygenErrorEnum.h>
#include <proxygen/lib/http/Window.h>
#include <proxygen/lib/http/codec/HTTPCodec.h>
#include <proxygen/lib/http/session/HTTP2PriorityQueue.h>
#include <proxygen/lib/http/session/HTTPEvent.h>
#include <proxygen/lib/http/session/HTTPTransactionEgressSM.h>
#include <proxygen/lib/http/session/HTTPTransactionIngressSM.h>
#include <proxygen/lib/utils/Time.h>
#include <proxygen/lib/utils/WheelTimerInstance.h>
#include <set>

namespace proxygen {

class TransactionInfo {
 public:
  TransactionInfo() {}

  TransactionInfo(
    std::chrono::milliseconds ttfb,
    std::chrono::milliseconds ttlb,
    uint64_t eHeader,
    uint64_t inHeader,
    uint64_t eBody,
    uint64_t inBody,
    bool completed):
      timeToFirstByte(ttfb),
      timeToLastByte(ttlb),
      egressHeaderBytes(eHeader),
      ingressHeaderBytes(inHeader),
      egressBodyBytes(eBody),
      ingressBodyBytes(inBody),
      isCompleted(completed) {
  }

  std::chrono::milliseconds timeToFirstByte{0};
  std::chrono::milliseconds timeToLastByte{0};

  uint64_t egressHeaderBytes{0};
  uint64_t ingressHeaderBytes{0};
  uint64_t egressBodyBytes{0};
  uint64_t ingressBodyBytes{0};

  bool isCompleted{false};
};

class HTTPSessionStats;
class HTTPTransaction;
class HTTPTransactionHandler {
 public:

  virtual void setTransaction(HTTPTransaction* txn) noexcept = 0;

  virtual void detachTransaction() noexcept = 0;

  virtual void onHeadersComplete(std::unique_ptr<HTTPMessage> msg) noexcept = 0;

  virtual void onBody(std::unique_ptr<folly::IOBuf> chain) noexcept = 0;

  virtual void onChunkHeader(size_t /* length */) noexcept {}

  virtual void onChunkComplete() noexcept {}

  virtual void onTrailers(std::unique_ptr<HTTPHeaders> trailers) noexcept
    = 0;

  virtual void onEOM() noexcept = 0;

  virtual void onUpgrade(UpgradeProtocol protocol) noexcept = 0;

  virtual void onError(const HTTPException& error) noexcept = 0;

  virtual void onEgressPaused() noexcept = 0;

  virtual void onEgressResumed() noexcept = 0;

  virtual void onPushedTransaction(HTTPTransaction* /* txn */) noexcept {}

  virtual void onExTransaction(HTTPTransaction* /* txn */) noexcept {}

  virtual void onGoaway(ErrorCode /* code */) noexcept {}

  virtual ~HTTPTransactionHandler() {}
};

class HTTPPushTransactionHandler : public HTTPTransactionHandler {
 public:
  ~HTTPPushTransactionHandler() override {}

  void onHeadersComplete(std::unique_ptr<HTTPMessage>) noexcept final {
    LOG(FATAL) << "push txn received headers";
  }

  void onBody(std::unique_ptr<folly::IOBuf>) noexcept final {
    LOG(FATAL) << "push txn received body";
  }

  void onChunkHeader(size_t /* length */) noexcept final {
    LOG(FATAL) << "push txn received chunk header";
  }

  void onChunkComplete() noexcept final {
    LOG(FATAL) << "push txn received chunk complete";
  }

  void onTrailers(std::unique_ptr<HTTPHeaders>) noexcept final {
    LOG(FATAL) << "push txn received trailers";
  }

  void onEOM() noexcept final {
    LOG(FATAL) << "push txn received EOM";
  }

  void onUpgrade(UpgradeProtocol) noexcept final {
    LOG(FATAL) << "push txn received upgrade";
  }

  void onPushedTransaction(HTTPTransaction*) noexcept final {
    LOG(FATAL) << "push txn received push txn";
  }
};

class HTTPTransactionTransportCallback {
 public:
  virtual void firstHeaderByteFlushed() noexcept = 0;

  virtual void firstByteFlushed() noexcept = 0;

  virtual void lastByteFlushed() noexcept = 0;

  virtual void trackedByteFlushed() noexcept {}

  virtual void lastByteAcked(std::chrono::milliseconds latency) noexcept = 0;

  virtual void headerBytesGenerated(HTTPHeaderSize& size) noexcept = 0;

  virtual void headerBytesReceived(const HTTPHeaderSize& size) noexcept = 0;

  virtual void bodyBytesGenerated(size_t nbytes) noexcept = 0;

  virtual void bodyBytesReceived(size_t size) noexcept = 0;

  virtual ~HTTPTransactionTransportCallback() {}
};

class HTTPTransaction :
      public folly::HHWheelTimer::Callback,
      public folly::DelayedDestructionBase {
 public:
  using Handler = HTTPTransactionHandler;
  using PushHandler = HTTPPushTransactionHandler;

  class Transport {
   public:
    virtual ~Transport() {}

    virtual void pauseIngress(HTTPTransaction* txn) noexcept = 0;

    virtual void resumeIngress(HTTPTransaction* txn) noexcept = 0;

    virtual void transactionTimeout(HTTPTransaction* txn) noexcept = 0;

    virtual void sendHeaders(HTTPTransaction* txn,
                             const HTTPMessage& headers,
                             HTTPHeaderSize* size,
                             bool eom) noexcept = 0;

    virtual size_t sendBody(HTTPTransaction* txn,
                            std::unique_ptr<folly::IOBuf>,
                            bool eom,
                            bool trackLastByteFlushed) noexcept = 0;

    virtual size_t sendChunkHeader(HTTPTransaction* txn,
                                   size_t length) noexcept = 0;

    virtual size_t sendChunkTerminator(HTTPTransaction* txn) noexcept = 0;

    virtual size_t sendEOM(HTTPTransaction* txn,
                           const HTTPHeaders* trailers) noexcept = 0;

    virtual size_t sendAbort(HTTPTransaction* txn,
                             ErrorCode statusCode) noexcept = 0;

    virtual size_t sendPriority(HTTPTransaction* txn,
                                const http2::PriorityUpdate& pri) noexcept = 0;

    virtual size_t sendWindowUpdate(HTTPTransaction* txn,
                                    uint32_t bytes) noexcept = 0;

    virtual void notifyPendingEgress() noexcept = 0;

    virtual void detach(HTTPTransaction* txn) noexcept = 0;

    virtual void notifyIngressBodyProcessed(uint32_t bytes) noexcept = 0;

    virtual void notifyEgressBodyBuffered(int64_t bytes) noexcept = 0;

    virtual const folly::SocketAddress& getLocalAddress()
      const noexcept = 0;

    virtual const folly::SocketAddress& getPeerAddress()
      const noexcept = 0;

    virtual void describe(std::ostream&) const = 0;

    virtual const wangle::TransportInfo& getSetupTransportInfo() const noexcept = 0;

    virtual bool getCurrentTransportInfo(wangle::TransportInfo* tinfo) = 0;

    virtual const HTTPCodec& getCodec() const noexcept = 0;

    /*
    * Drain the underlying session. This will affect other transactions
    * running on the same session and is discouraged unless you are confident
    * that the session is broken.
    */
    virtual void drain() = 0;

    virtual bool isDraining() const = 0;

    virtual HTTPTransaction* newPushedTransaction(
      HTTPCodec::StreamID assocStreamId,
      HTTPTransaction::PushHandler* handler) noexcept = 0;

    virtual HTTPTransaction* newExTransaction(
      HTTPTransaction::Handler* handler,
      HTTPCodec::StreamID controlStream,
      bool unidirectional) noexcept = 0;

    virtual std::string getSecurityProtocol() const = 0;

    virtual void addWaitingForReplaySafety(
        folly::AsyncTransport::ReplaySafetyCallback* callback) noexcept = 0;

    virtual void removeWaitingForReplaySafety(
        folly::AsyncTransport::ReplaySafetyCallback* callback) noexcept = 0;

    virtual bool needToBlockForReplaySafety() const = 0;

    virtual const folly::AsyncTransportWrapper* getUnderlyingTransport()
      const noexcept = 0;

    virtual bool isReplaySafe() const = 0;

    virtual void setHTTP2PrioritiesEnabled(bool enabled) = 0;
    virtual bool getHTTP2PrioritiesEnabled() const = 0;

    virtual folly::Optional<const HTTPMessage::HTTPPriority>
        getHTTPPriority(uint8_t level) = 0;
  };

  using TransportCallback = HTTPTransactionTransportCallback;

  HTTPTransaction(TransportDirection direction,
                  HTTPCodec::StreamID id,
                  uint32_t seqNo,
                  Transport& transport,
                  HTTP2PriorityQueueBase& egressQueue,
                  folly::HHWheelTimer* timer = nullptr,
                  const folly::Optional<std::chrono::milliseconds>&
                  defaultTimeout = folly::Optional<std::chrono::milliseconds>(),
                  HTTPSessionStats* stats = nullptr,
                  bool useFlowControl = false,
                  uint32_t receiveInitialWindowSize = 0,
                  uint32_t sendInitialWindowSize = 0,
                  http2::PriorityUpdate = http2::DefaultPriority,
                  folly::Optional<HTTPCodec::StreamID> assocStreamId =
                  HTTPCodec::NoStream,
                  folly::Optional<HTTPCodec::ExAttributes> exAttributes =
                  HTTPCodec::NoExAttributes);

  ~HTTPTransaction() override;

  void reset(bool useFlowControl,
             uint32_t receiveInitialWindowSize,
             uint32_t receiveStreamWindowSize,
             uint32_t sendInitialWindowSize);

  HTTPCodec::StreamID getID() const { return id_; }

  uint32_t getSequenceNumber() const { return seqNo_; }

  const Transport& getTransport() const { return transport_; }

  Transport& getTransport() { return transport_; }

  virtual void setHandler(Handler* handler) {
    handler_ = handler;
    if (handler_) {
      handler_->setTransaction(this);
    }
  }

  const Handler* getHandler() const {
    return handler_;
  }

  http2::PriorityUpdate getPriority() const {
    return priority_;
  }

  std::tuple<uint64_t, uint64_t, double> getPrioritySummary() const {
    return std::make_tuple(
        insertDepth_,
        currentDepth_,
        egressCalls_ > 0 ? cumulativeRatio_ / egressCalls_ : 0);
  }

  bool getPriorityFallback() const {
    return priorityFallback_;
  }

  HTTPTransactionEgressSM::State getEgressState() const {
    return egressState_;
  }

  HTTPTransactionIngressSM::State getIngressState() const {
    return ingressState_;
  }

  bool isUpstream() const {
    return direction_ == TransportDirection::UPSTREAM;
  }

  bool isDownstream() const {
    return direction_ == TransportDirection::DOWNSTREAM;
  }

  void getLocalAddress(folly::SocketAddress& addr) const {
    addr = transport_.getLocalAddress();
  }

  void getPeerAddress(folly::SocketAddress& addr) const {
    addr = transport_.getPeerAddress();
  }

  const folly::SocketAddress& getLocalAddress()
    const noexcept {
    return transport_.getLocalAddress();
  }

  const folly::SocketAddress& getPeerAddress()
    const noexcept {
    return transport_.getPeerAddress();
  }

  const wangle::TransportInfo& getSetupTransportInfo() const noexcept {
    return transport_.getSetupTransportInfo();
  }

  void getCurrentTransportInfo(wangle::TransportInfo* tinfo) const {
    transport_.getCurrentTransportInfo(tinfo);
  }

  HTTPSessionStats* getSessionStats() const {
    return stats_;
  }

  virtual bool extraResponseExpected() const {
    return (lastResponseStatus_ >= 100 && lastResponseStatus_ < 200)
        && lastResponseStatus_ != 101;
  }

  virtual void setReceiveWindow(uint32_t capacity);

  virtual const Window& getReceiveWindow() const {
    return recvWindow_;
  }

  uint32_t getMaxDeferredSize() {
    return maxDeferredIngress_;
  }

  void onIngressHeadersComplete(std::unique_ptr<HTTPMessage> msg);

  void onIngressBody(std::unique_ptr<folly::IOBuf> chain, uint16_t padding);

  void onIngressChunkHeader(size_t length);

  void onIngressChunkComplete();

  void onIngressTrailers(std::unique_ptr<HTTPHeaders> trailers);

  void onIngressUpgrade(UpgradeProtocol protocol);

  void onIngressEOM();

  void onError(const HTTPException& error);

  void onGoaway(ErrorCode code);

  void onIngressTimeout();

  void onIngressWindowUpdate(uint32_t amount);

  void onIngressSetSendWindow(uint32_t newWindowSize);

  bool onWriteReady(uint32_t maxEgress, double ratio);

  void onEgressTimeout();

  void onEgressHeaderFirstByte();

  void onEgressBodyFirstByte();

  void onEgressBodyLastByte();

  void onEgressTrackedByte();

  void onEgressLastByteAck(std::chrono::milliseconds latency);

  void setTransportCallback(TransportCallback* cb) {
    transportCallback_ = cb;
  }

  bool isIngressStarted() const {
    return ingressState_ != HTTPTransactionIngressSM::State::Start;
  }

  bool isIngressEOMQueued() const {
    return ingressState_ == HTTPTransactionIngressSM::State::EOMQueued;
  }

  bool isIngressComplete() const {
    return ingressState_ == HTTPTransactionIngressSM::State::ReceivingDone;
  }

  bool isIngressEOMSeen() const {
    return isIngressEOMQueued() || isIngressComplete();
  }

  bool isEgressStarted() const {
    return egressState_ != HTTPTransactionEgressSM::State::Start;
  }

  bool isEgressEOMQueued() const {
    return egressState_ == HTTPTransactionEgressSM::State::EOMQueued;
  }

  bool isEgressComplete() const {
    return egressState_ == HTTPTransactionEgressSM::State::SendingDone;
  }

  bool isRemoteInitiated() const {
    return (direction_ == TransportDirection::DOWNSTREAM && id_ % 2 == 1) ||
           (direction_ == TransportDirection::UPSTREAM && id_ % 2 == 0);
  }

  bool isEgressEOMSeen() const {
    return isEgressEOMQueued() || isEgressComplete();
  }

  virtual bool canSendHeaders() const {
    return HTTPTransactionEgressSM::canTransit(
        egressState_,
        HTTPTransactionEgressSM::Event::sendHeaders)
      && (isUpstream() || lastResponseStatus_ == 0 || extraResponseExpected());
  }

  virtual void sendHeaders(const HTTPMessage& headers);
  virtual void sendHeadersWithEOM(const HTTPMessage& headers);
  virtual void sendHeadersWithOptionalEOM(const HTTPMessage& headers, bool eom);

  virtual void sendBody(std::unique_ptr<folly::IOBuf> body);

  virtual void sendChunkHeader(size_t length) {
    CHECK(HTTPTransactionEgressSM::transit(
            egressState_, HTTPTransactionEgressSM::Event::sendChunkHeader));
    // TODO: move this logic down to session/codec
    if (!transport_.getCodec().supportsParallelRequests()) {
      chunkHeaders_.emplace_back(Chunk(length));
    }
  }

  virtual void sendChunkTerminator() {
    CHECK(HTTPTransactionEgressSM::transit(
            egressState_, HTTPTransactionEgressSM::Event::sendChunkTerminator));
  }

  virtual void sendTrailers(const HTTPHeaders& trailers) {
    CHECK(HTTPTransactionEgressSM::transit(
            egressState_, HTTPTransactionEgressSM::Event::sendTrailers));
    trailers_.reset(new HTTPHeaders(trailers));
  }

  virtual void sendEOM();

  virtual void sendAbort();

  virtual void pauseIngress();

  virtual void resumeIngress();

  bool isIngressPaused() const { return ingressPaused_; }

  void pauseEgress();

  void resumeEgress();

  void setEgressRateLimit(uint64_t bitsPerSecond);

  bool isEgressPaused() const { return handlerEgressPaused_; }

  bool isFlowControlPaused() const { return flowControlPaused_; }

  bool supportsPushTransactions() const {
    return direction_ == TransportDirection::DOWNSTREAM &&
      transport_.getCodec().supportsPushTransactions();
  }

  virtual HTTPTransaction* newPushedTransaction(
    HTTPPushTransactionHandler* handler) {
    if (isEgressEOMSeen()) {
      return nullptr;
    }
    auto txn = transport_.newPushedTransaction(id_, handler);
    if (txn) {
      pushedTransactions_.insert(txn->getID());
    }
    return txn;
  }

  virtual HTTPTransaction* newExTransaction(HTTPTransactionHandler* handler,
                                            bool unidirectional = false) {
    auto txn = transport_.newExTransaction(handler, id_, unidirectional);
    if (txn) {
      exTransactions_.insert(txn->getID());
    }
    return txn;
  }

  bool onPushedTransaction(HTTPTransaction* txn);

  bool onExTransaction(HTTPTransaction* txn);

  bool isPushed() const {
    return assocStreamId_.has_value();
  }

  bool isExTransaction() const {
    return exAttributes_.has_value();
  }

  bool isUnidirectional() const {
    return isExTransaction() && exAttributes_->unidirectional;
  }

  void setIdleTimeout(std::chrono::milliseconds transactionTimeout);

  bool hasIdleTimeout() const {
    return transactionTimeout_.hasValue();
  }

  std::chrono::milliseconds getIdleTimeout() const {
    return transactionTimeout_.value();
  }

  folly::Optional<HTTPCodec::StreamID> getAssocTxnId() const {
    return assocStreamId_;
  }

  folly::Optional<HTTPCodec::StreamID> getControlStream() const {
    return exAttributes_ ? exAttributes_->controlStream : HTTPCodec::NoStream;
  }


  /*
   * Returns attributes of EX stream (folly::none if not an EX transaction)
   */
  folly::Optional<HTTPCodec::ExAttributes> getExAttributes() const {
    return exAttributes_;
  }

  const std::set<HTTPCodec::StreamID>& getPushedTransactions() const {
    return pushedTransactions_;
  }

  std::set<HTTPCodec::StreamID> getExTransactions() const {
    return exTransactions_;
  }

  void removePushedTransaction(HTTPCodec::StreamID pushStreamId) {
    pushedTransactions_.erase(pushStreamId);
  }

  void removeExTransaction(HTTPCodec::StreamID exStreamId) {
    exTransactions_.erase(exStreamId);
  }

  void refreshTimeout() {
    if (timer_ && hasIdleTimeout()) {
      timer_->scheduleTimeout(this, transactionTimeout_.value());
    }
  }

  bool testAndSetFirstByteSent() {
    bool ret = firstByteSent_;
    firstByteSent_ = true;
    return ret;
  }

  bool testAndClearActive() {
    bool ret = inActiveSet_;
    inActiveSet_ = false;
    return ret;
  }

  bool testAndSetFirstHeaderByteSent() {
    bool ret = firstHeaderByteSent_;
    firstHeaderByteSent_ = true;
    return ret;
  }

  void incrementPendingByteEvents() {
    CHECK_LT(pendingByteEvents_, std::numeric_limits<uint8_t>::max());
    pendingByteEvents_++;
  }

  void decrementPendingByteEvents() {
    DestructorGuard dg(this);
    CHECK_GT(pendingByteEvents_, 0);
    pendingByteEvents_--;
  }

  void timeoutExpired() noexcept override {
    transport_.transactionTimeout(this);
  }

  void describe(std::ostream& os) const;

  void updateAndSendPriority(int8_t newPriority);
  void updateAndSendPriority(const http2::PriorityUpdate& pri);

  void onPriorityUpdate(const http2::PriorityUpdate& priority);

  virtual void addWaitingForReplaySafety(
      folly::AsyncTransport::ReplaySafetyCallback* callback) {
    transport_.addWaitingForReplaySafety(callback);
  }

  virtual void removeWaitingForReplaySafety(
      folly::AsyncTransport::ReplaySafetyCallback* callback) {
    transport_.removeWaitingForReplaySafety(callback);
  }

  virtual bool needToBlockForReplaySafety() const {
    return transport_.needToBlockForReplaySafety();
  }

  int32_t getRecvToAck() const;

  bool isPrioritySampled() const {
    return prioritySample_ != nullptr;
  }

  void setPrioritySampled(bool sampled);
  void updateContentionsCount(uint64_t contentions);
  void updateRelativeWeight(double ratio);
  void updateSessionBytesSheduled(uint64_t bytes);
  void updateTransactionBytesSent(uint64_t bytes);

  struct PrioritySampleSummary {
    struct WeightedAverage {
      double byTransactionBytes_{0};
      double bySessionBytes_{0};
    };
    WeightedAverage contentions_;
    WeightedAverage depth_;
    double expected_weight_;
    double measured_weight_;
  };

  bool getPrioritySampleSummary(PrioritySampleSummary& summary) const;

  HPACKTableInfo& getHPACKTableInfo();

  bool hasPendingBody() const {
    return deferredEgressBody_.chainLength() > 0;
  }

  void setLastByteFlushedTrackingEnabled(bool enabled) {
    enableLastByteFlushedTracking_ = enabled;
  }

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

  void onDelayedDestroy(bool delayed) override;

  void updateHandlerPauseState();

  void updateEgressHPACKTableInfo(HPACKTableInfo);

  void updateIngressHPACKTableInfo(HPACKTableInfo);

  bool mustQueueIngress() const;

  void checkCreateDeferredIngress();

  void sendAbort(ErrorCode statusCode);

  // Internal implementations of the ingress-related callbacks
  // that work whether the ingress events are immediate or deferred.
  void processIngressHeadersComplete(std::unique_ptr<HTTPMessage> msg);
  void processIngressBody(std::unique_ptr<folly::IOBuf> chain, size_t len);
  void processIngressChunkHeader(size_t length);
  void processIngressChunkComplete();
  void processIngressTrailers(std::unique_ptr<HTTPHeaders> trailers);
  void processIngressUpgrade(UpgradeProtocol protocol);
  void processIngressEOM();

  void sendBodyFlowControlled(std::unique_ptr<folly::IOBuf> body = nullptr);
  size_t sendBodyNow(std::unique_ptr<folly::IOBuf> body, size_t bodyLen,
                     bool eom);
  size_t sendEOMNow();
  void onDeltaSendWindowSize(int32_t windowDelta);

  void notifyTransportPendingEgress();

  size_t sendDeferredBody(uint32_t maxEgress);

  bool maybeDelayForRateLimit();

  bool isEnqueued() const { return queueHandle_->isEnqueued(); }

  void dequeue() {
    DCHECK(isEnqueued());
    egressQueue_.clearPendingEgress(queueHandle_);
  }

  bool hasPendingEOM() const {
    return deferredEgressBody_.chainLength() == 0 &&
      isEgressEOMQueued();
  }

  bool isExpectingIngress() const;

  bool isExpectingWindowUpdate() const;

  void updateReadTimeout();

  void markIngressComplete();

  void markEgressComplete();

  bool validateIngressStateTransition(HTTPTransactionIngressSM::Event);

  void flushWindowUpdate();

  void rateLimitTimeoutExpired();

  class RateLimitCallback : public folly::HHWheelTimer::Callback {
   public:
    explicit RateLimitCallback(HTTPTransaction& txn)
        : txn_(txn) {}

    void timeoutExpired() noexcept override {
      txn_.rateLimitTimeoutExpired();
    }
    void callbackCanceled() noexcept override {
      // no op
    }
   private:
    HTTPTransaction& txn_;
  };

  RateLimitCallback rateLimitCallback_{*this};

  std::unique_ptr<std::queue<HTTPEvent>> deferredIngress_;

  uint32_t maxDeferredIngress_{0};

  folly::IOBufQueue deferredEgressBody_{folly::IOBufQueue::cacheChainLength()};

  const TransportDirection direction_;
  HTTPCodec::StreamID id_;
  uint32_t seqNo_;
  Handler* handler_{nullptr};
  Transport& transport_;
  HTTPTransactionEgressSM::State egressState_{
    HTTPTransactionEgressSM::getNewInstance()};
  HTTPTransactionIngressSM::State ingressState_{
    HTTPTransactionIngressSM::getNewInstance()};

  HTTPSessionStats* stats_{nullptr};

  HPACKTableInfo tableInfo_;

  Window recvWindow_;

  Window sendWindow_;

  TransportCallback* transportCallback_{nullptr};

  std::unique_ptr<HTTPHeaders> trailers_;

  struct Chunk {
    explicit Chunk(size_t inLength) : length(inLength), headerSent(false) {}
    size_t length;
    bool headerSent;
  };
  std::list<Chunk> chunkHeaders_;

  HTTP2PriorityQueueBase& egressQueue_;

  HTTP2PriorityQueueBase::Handle queueHandle_;

  int32_t recvToAck_{0};

  folly::Optional<HTTPCodec::StreamID> assocStreamId_;

  folly::Optional<HTTPCodec::ExAttributes> exAttributes_;

  std::set<HTTPCodec::StreamID> pushedTransactions_;

  std::set<HTTPCodec::StreamID> exTransactions_;

  http2::PriorityUpdate priority_;

  uint64_t insertDepth_{0};
  uint64_t currentDepth_{0};
  double cumulativeRatio_{0};
  uint64_t egressCalls_{0};

  uint16_t lastResponseStatus_{0};
  uint8_t pendingByteEvents_{0};
  folly::Optional<uint64_t> expectedContentLengthRemaining_;
  folly::Optional<uint64_t> expectedResponseLength_;
  folly::Optional<uint64_t> actualResponseLength_{0};

  bool ingressPaused_:1;
  bool egressPaused_:1;
  bool flowControlPaused_:1;
  bool handlerEgressPaused_:1;
  bool egressRateLimited_:1;
  bool useFlowControl_:1;
  bool aborted_:1;
  bool deleting_:1;
  bool firstByteSent_:1;
  bool firstHeaderByteSent_:1;
  bool inResume_:1;
  bool inActiveSet_:1;
  bool ingressErrorSeen_:1;
  bool priorityFallback_:1;
  bool headRequest_:1;
  bool enableLastByteFlushedTracking_:1;

  static uint64_t egressBufferLimit_;

  uint64_t egressLimitBytesPerMs_{0};
  proxygen::TimePoint startRateLimit_;
  uint64_t numLimitedBytesEgressed_{0};

  folly::Optional<std::chrono::milliseconds> transactionTimeout_;

  folly::HHWheelTimer* timer_;

  class PrioritySample;
  std::unique_ptr<PrioritySample> prioritySample_;
};

std::ostream& operator<<(std::ostream& os, const HTTPTransaction& txn);

} // proxygen