proxygen: proxygen::HTTPTransaction Class Reference

#include <HTTPTransaction.h>

Inheritance diagram for proxygen::HTTPTransaction:

Classes
struct	Chunk

class	PrioritySample

struct	PrioritySampleSummary

class	RateLimitCallback

class	Transport

Public Types
using	Handler = HTTPTransactionHandler

using	PushHandler = HTTPPushTransactionHandler

using	TransportCallback = HTTPTransactionTransportCallback

Public Member Functions
	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

uint32_t	getSequenceNumber () const

const Transport &	getTransport () const

Transport &	getTransport ()

virtual void	setHandler (Handler *handler)

const Handler *	getHandler () const

http2::PriorityUpdate	getPriority () const

std::tuple< uint64_t, uint64_t, double >	getPrioritySummary () const

bool	getPriorityFallback () const

HTTPTransactionEgressSM::State	getEgressState () const

HTTPTransactionIngressSM::State	getIngressState () const

bool	isUpstream () const

bool	isDownstream () const

void	getLocalAddress (folly::SocketAddress &addr) const

void	getPeerAddress (folly::SocketAddress &addr) const

const folly::SocketAddress &	getLocalAddress () const noexcept

const folly::SocketAddress &	getPeerAddress () const noexcept

const wangle::TransportInfo &	getSetupTransportInfo () const noexcept

void	getCurrentTransportInfo (wangle::TransportInfo *tinfo) const

HTTPSessionStats *	getSessionStats () const

virtual bool	extraResponseExpected () const

virtual void	setReceiveWindow (uint32_t capacity)

virtual const Window &	getReceiveWindow () const

uint32_t	getMaxDeferredSize ()

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)

bool	isIngressStarted () const

bool	isIngressEOMQueued () const

bool	isIngressComplete () const

bool	isIngressEOMSeen () const

bool	isEgressStarted () const

bool	isEgressEOMQueued () const

bool	isEgressComplete () const

bool	isRemoteInitiated () const

bool	isEgressEOMSeen () const

virtual bool	canSendHeaders () const

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)

virtual void	sendChunkTerminator ()

virtual void	sendTrailers (const HTTPHeaders &trailers)

virtual void	sendEOM ()

virtual void	sendAbort ()

virtual void	pauseIngress ()

virtual void	resumeIngress ()

bool	isIngressPaused () const

void	pauseEgress ()

void	resumeEgress ()

void	setEgressRateLimit (uint64_t bitsPerSecond)

bool	isEgressPaused () const

bool	isFlowControlPaused () const

bool	supportsPushTransactions () const

virtual HTTPTransaction *	newPushedTransaction (HTTPPushTransactionHandler *handler)

virtual HTTPTransaction *	newExTransaction (HTTPTransactionHandler *handler, bool unidirectional=false)

bool	onPushedTransaction (HTTPTransaction *txn)

bool	onExTransaction (HTTPTransaction *txn)

bool	isPushed () const

bool	isExTransaction () const

bool	isUnidirectional () const

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

bool	hasIdleTimeout () const

std::chrono::milliseconds	getIdleTimeout () const

folly::Optional< HTTPCodec::StreamID >	getAssocTxnId () const

folly::Optional< HTTPCodec::StreamID >	getControlStream () const

folly::Optional< HTTPCodec::ExAttributes >	getExAttributes () const

const std::set< HTTPCodec::StreamID > &	getPushedTransactions () const

std::set< HTTPCodec::StreamID >	getExTransactions () const

void	removePushedTransaction (HTTPCodec::StreamID pushStreamId)

void	removeExTransaction (HTTPCodec::StreamID exStreamId)

void	refreshTimeout ()

bool	testAndSetFirstByteSent ()

bool	testAndClearActive ()

bool	testAndSetFirstHeaderByteSent ()

void	incrementPendingByteEvents ()

void	decrementPendingByteEvents ()

void	timeoutExpired () noexceptoverride

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)

virtual void	removeWaitingForReplaySafety (folly::AsyncTransport::ReplaySafetyCallback *callback)

virtual bool	needToBlockForReplaySafety () const

int32_t	getRecvToAck () const

bool	isPrioritySampled () const

void	setPrioritySampled (bool sampled)

void	updateContentionsCount (uint64_t contentions)

void	updateRelativeWeight (double ratio)

void	updateSessionBytesSheduled (uint64_t bytes)

void	updateTransactionBytesSent (uint64_t bytes)

bool	getPrioritySampleSummary (PrioritySampleSummary &summary) const

HPACKTableInfo &	getHPACKTableInfo ()

bool	hasPendingBody () const

void	setLastByteFlushedTrackingEnabled (bool enabled)

Public Member Functions inherited from folly::HHWheelTimer::Callback
	Callback ()=default

virtual	~Callback ()

virtual void	callbackCanceled () noexcept

void	cancelTimeout ()

bool	isScheduled () const

std::chrono::milliseconds	getTimeRemaining ()

Public Member Functions inherited from folly::DelayedDestructionBase
virtual	~DelayedDestructionBase ()=default

Private Member Functions
	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)

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

void	dequeue ()

bool	hasPendingEOM () const

bool	isExpectingIngress () const

bool	isExpectingWindowUpdate () const

void	updateReadTimeout ()

void	markIngressComplete ()

void	markEgressComplete ()

bool	validateIngressStateTransition (HTTPTransactionIngressSM::Event)

void	flushWindowUpdate ()

void	rateLimitTimeoutExpired ()

Private Attributes
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_

HTTPTransactionIngressSM::State	ingressState_

HTTPSessionStats *	stats_ {nullptr}

HPACKTableInfo	tableInfo_

Window	recvWindow_

Window	sendWindow_

TransportCallback *	transportCallback_ {nullptr}

std::unique_ptr< HTTPHeaders >	trailers_

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

uint64_t	egressLimitBytesPerMs_ {0}

proxygen::TimePoint	startRateLimit_

uint64_t	numLimitedBytesEgressed_ {0}

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

folly::HHWheelTimer *	timer_

std::unique_ptr< PrioritySample >	prioritySample_

Static Private Attributes
static uint64_t	egressBufferLimit_

Additional Inherited Members
Protected Member Functions inherited from folly::HHWheelTimer::Callback
virtual std::chrono::steady_clock::time_point	getCurTime ()

Protected Member Functions inherited from folly::DelayedDestructionBase
	DelayedDestructionBase ()

uint32_t	getDestructorGuardCount () const

Detailed Description

Definition at line 324 of file HTTPTransaction.h.

Member Typedef Documentation

using proxygen::HTTPTransaction::Handler = HTTPTransactionHandler

Definition at line 328 of file HTTPTransaction.h.

using proxygen::HTTPTransaction::PushHandler = HTTPPushTransactionHandler

Definition at line 329 of file HTTPTransaction.h.

using proxygen::HTTPTransaction::TransportCallback = HTTPTransactionTransportCallback

Definition at line 433 of file HTTPTransaction.h.

Constructor & Destructor Documentation

proxygen::HTTPTransaction::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	priority = `http2::DefaultPriority`,
		folly::Optional< HTTPCodec::StreamID >	assocStreamId = `HTTPCodec::NoStream`,
		folly::Optional< HTTPCodec::ExAttributes >	exAttributes = `HTTPCodec::NoExAttributes`
	)

readBufLimit and sendWindow are only used if useFlowControl is true. Furthermore, if flow control is enabled, no guarantees can be made on the borders of the L7 chunking/data frames of the outbound messages.

priority is only used by SPDY. The -1 default makes sure that all plain HTTP transactions land up in the same queue as the control data.

Definition at line 31 of file HTTPTransaction.cpp.

References proxygen::HTTP2PriorityQueueBase::addTransaction(), assocStreamId_, currentDepth_, egressQueue_, egressState_, exAttributes_, id_, ingressState_, insertDepth_, isRemoteInitiated(), isUpstream(), priorityFallback_, queueHandle_, proxygen::HTTPSessionStats::recordTransactionOpened(), refreshTimeout(), stats_, and proxygen::http2::PriorityUpdate::streamDependency.

                                               :
     deferredEgressBody_(folly::IOBufQueue::cacheChainLength()),
     direction_(direction),
     id_(id),
     seqNo_(seqNo),
     transport_(transport),
     stats_(stats),
     recvWindow_(receiveInitialWindowSize),
     sendWindow_(sendInitialWindowSize),
     egressQueue_(egressQueue),
     assocStreamId_(assocId),
     priority_(priority),
     ingressPaused_(false),
     egressPaused_(false),
     flowControlPaused_(false),
     handlerEgressPaused_(false),
     egressRateLimited_(false),
     useFlowControl_(useFlowControl),
     aborted_(false),
     deleting_(false),
     firstByteSent_(false),
     firstHeaderByteSent_(false),
     inResume_(false),
     inActiveSet_(true),
     ingressErrorSeen_(false),
     priorityFallback_(false),
     headRequest_(false),
     enableLastByteFlushedTracking_(false),
     transactionTimeout_(defaultTimeout),
     timer_(timer) {
 
   if (assocStreamId_) {
     if (isUpstream()) {
       egressState_ = HTTPTransactionEgressSM::State::SendingDone;
     } else {
       ingressState_ = HTTPTransactionIngressSM::State::ReceivingDone;
     }
   }
 
   if (exAttributes) {
     exAttributes_ = exAttributes;
     if (exAttributes_->unidirectional) {
       if (isRemoteInitiated()) {
         egressState_ = HTTPTransactionEgressSM::State::SendingDone;
       } else {
         ingressState_ = HTTPTransactionIngressSM::State::ReceivingDone;
       }
     }
   }
 
   refreshTimeout();
   if (stats_) {
     stats_->recordTransactionOpened();
   }
 
   queueHandle_ = egressQueue_.addTransaction(id_, priority, this, false,
                                              &insertDepth_);
   if(priority.streamDependency != 0 && insertDepth_ == 1) {
     priorityFallback_ = true;
   }
 
   currentDepth_ = insertDepth_;
 }

proxygen::HTTPTransaction::~HTTPTransaction ( )

override

Definition at line 131 of file HTTPTransaction.cpp.

References folly::HHWheelTimer::Callback::cancelTimeout(), dequeue(), egressQueue_, isEnqueued(), folly::HHWheelTimer::Callback::isScheduled(), queueHandle_, proxygen::HTTPSessionStats::recordTransactionClosed(), proxygen::HTTP2PriorityQueueBase::removeTransaction(), and stats_.

                                   {
   // Cancel transaction timeout if still scheduled.
   if (isScheduled()) {
     cancelTimeout();
   }
 
   if (stats_) {
     stats_->recordTransactionClosed();
   }
   if (isEnqueued()) {
     dequeue();
   }
   // TODO: handle the case where the priority node hangs out longer than
   // the transaction
   egressQueue_.removeTransaction(queueHandle_);
 }

proxygen::HTTPTransaction::HTTPTransaction ( const HTTPTransaction & )

privatedelete

Member Function Documentation

virtual void proxygen::HTTPTransaction::addWaitingForReplaySafety ( folly::AsyncTransport::ReplaySafetyCallback * callback )

inlinevirtual

Add a callback waiting for this transaction to have a transport with replay protection.

Definition at line 1176 of file HTTPTransaction.h.

References transport_.

                                                          {
     transport_.addWaitingForReplaySafety(callback);
   }

virtual bool proxygen::HTTPTransaction::canSendHeaders ( ) const

inlinevirtual

Returns: true if we can send headers on this transaction

Here's the logic: 1) state machine says sendHeaders is OK AND 2a) this is an upstream (allows for mid-stream headers) OR 2b) this downstream has not sent a response 2c) this downstream has only sent 1xx responses

Definition at line 781 of file HTTPTransaction.h.

References proxygen::StateMachine< T >::canTransit().

Referenced by proxygen::RequestHandlerAdaptor::onError().

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

void proxygen::HTTPTransaction::checkCreateDeferredIngress ( )

private

Check if deferredIngress_ points to some queue before pushing HTTPEvent to it.

Definition at line 1257 of file HTTPTransaction.cpp.

References deferredIngress_.

Referenced by onIngressBody(), onIngressChunkComplete(), onIngressChunkHeader(), onIngressEOM(), onIngressHeadersComplete(), onIngressTrailers(), and onIngressUpgrade().

                                                  {
   if (!deferredIngress_) {
     deferredIngress_ = std::make_unique<std::queue<HTTPEvent>>();
   }
 }

void proxygen::HTTPTransaction::decrementPendingByteEvents ( )

inline

Definition at line 1142 of file HTTPTransaction.h.

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

void proxygen::HTTPTransaction::dequeue ( )

inlineprivate

Definition at line 1284 of file HTTPTransaction.h.

Referenced by markEgressComplete(), sendDeferredBody(), and ~HTTPTransaction().

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

void proxygen::HTTPTransaction::describe ( std::ostream & os ) const

Write a description of the transaction to a stream

Definition at line 1305 of file HTTPTransaction.cpp.

References proxygen::HTTPTransaction::Transport::describe(), id_, and transport_.

Referenced by proxygen::operator<<().

                                                    {
   transport_.describe(os);
   os << ", streamID=" << id_;
 }

virtual bool proxygen::HTTPTransaction::extraResponseExpected ( ) const

inlinevirtual

Check whether more response is expected. One or more 1xx status responses can be received prior to the regular response. Note: 101 is handled by the codec using a separate onUpgrade callback

Definition at line 554 of file HTTPTransaction.h.

References uint32_t.

Referenced by onIngressEOM(), and proxygen::HTTPSession::onMessageComplete().

                                              {
     return (lastResponseStatus_ >= 100 && lastResponseStatus_ < 200)
         && lastResponseStatus_ != 101;
   }

void proxygen::HTTPTransaction::flushWindowUpdate ( )

private

Flushes any pending window updates. This can happen from setReceiveWindow or sendHeaders depending on transaction state.

Definition at line 1335 of file HTTPTransaction.cpp.

References direction_, proxygen::DOWNSTREAM, egressState_, proxygen::Window::getCapacity(), proxygen::Window::getSize(), ingressState_, isIngressEOMSeen(), recvToAck_, recvWindow_, proxygen::HTTPTransaction::Transport::sendWindowUpdate(), transport_, and useFlowControl_.

Referenced by processIngressBody(), sendHeadersWithOptionalEOM(), and setReceiveWindow().

                                         {
   if (recvToAck_ > 0 && useFlowControl_ && !isIngressEOMSeen() &&
       (direction_ == TransportDirection::DOWNSTREAM ||
         egressState_ != HTTPTransactionEgressSM::State::Start ||
         ingressState_ != HTTPTransactionIngressSM::State::Start)) {
     // Down egress upstream window updates until after headers
     VLOG(4) << "recv_window is " << recvWindow_.getSize()
             << " / " << recvWindow_.getCapacity() << " after acking "
             << recvToAck_ << " " << *this ;
     transport_.sendWindowUpdate(this, recvToAck_);
     recvToAck_ = 0;
   }
 }

folly::Optional<HTTPCodec::StreamID> proxygen::HTTPTransaction::getAssocTxnId ( ) const

inline

Returns the associated transaction ID for pushed transactions, 0 otherwise

Definition at line 1048 of file HTTPTransaction.h.

Referenced by proxygen::HTTPSession::onAbort().

                                                          {
     return assocStreamId_;
   }

folly::Optional<HTTPCodec::StreamID> proxygen::HTTPTransaction::getControlStream ( ) const

inline

Returns the control channel transaction ID for this transaction, folly::none otherwise

Definition at line 1056 of file HTTPTransaction.h.

References proxygen::HTTPCodec::NoStream.

Referenced by onExTransaction(), proxygen::HTTPSession::onHeadersComplete(), and proxygen::HTTPDownstreamSession::setupOnHeadersComplete().

                                                             {
     return exAttributes_ ? exAttributes_->controlStream : HTTPCodec::NoStream;
   }

void proxygen::HTTPTransaction::getCurrentTransportInfo ( wangle::TransportInfo * tinfo ) const

inline

Definition at line 541 of file HTTPTransaction.h.

References transport_.

Referenced by proxygen::RequestHandlerAdaptor::getCurrentTransportInfo().

                                                                  {
     transport_.getCurrentTransportInfo(tinfo);
   }

HTTPTransactionEgressSM::State proxygen::HTTPTransaction::getEgressState ( ) const

inline

Definition at line 503 of file HTTPTransaction.h.

Referenced by proxygen::HTTPSession::onError().

                                                       {
     return egressState_;
   }

folly::Optional<HTTPCodec::ExAttributes> proxygen::HTTPTransaction::getExAttributes ( ) const

inline

Definition at line 1064 of file HTTPTransaction.h.

                                                                {
     return exAttributes_;
   }

std::set<HTTPCodec::StreamID> proxygen::HTTPTransaction::getExTransactions ( ) const

inline

Get a set of exTransactions associated with this transaction.

Definition at line 1078 of file HTTPTransaction.h.

Referenced by proxygen::HTTPSession::onAbort().

                                                       {
     return exTransactions_;
   }

const Handler* proxygen::HTTPTransaction::getHandler ( ) const

inline

Definition at line 484 of file HTTPTransaction.h.

Referenced by proxygen::HTTPSession::onError(), onExTransaction(), onPushedTransaction(), and proxygen::HTTPDownstreamSession::setupOnHeadersComplete().

                                     {
     return handler_;
   }

HPACKTableInfo & proxygen::HTTPTransaction::getHPACKTableInfo ( )

Definition at line 1249 of file HTTPTransaction.cpp.

References tableInfo_.

                                                    {
   return tableInfo_;
 }

HTTPCodec::StreamID proxygen::HTTPTransaction::getID ( ) const

inline

Definition at line 469 of file HTTPTransaction.h.

Referenced by proxygen::HTTPSession::createTransaction(), proxygen::HTTPSession::newExTransaction(), proxygen::HTTPSession::newPushedTransaction(), onExTransaction(), onPushedTransaction(), proxygen::HTTPDownstreamSession::setupOnHeadersComplete(), and TEST_F().

469 { return id_; }

proxygen::HTTPTransaction::id_

HTTPCodec::StreamID id_

Definition: HTTPTransaction.h:1359

std::chrono::milliseconds proxygen::HTTPTransaction::getIdleTimeout ( ) const

inline

Returns the transaction timeout if exists. An OptionalEmptyException is raised if the timeout isn't set.

Definition at line 1041 of file HTTPTransaction.h.

                                                {
     return transactionTimeout_.value();
   }

HTTPTransactionIngressSM::State proxygen::HTTPTransaction::getIngressState ( ) const

inline

Definition at line 507 of file HTTPTransaction.h.

                                                         {
     return ingressState_;
   }

void proxygen::HTTPTransaction::getLocalAddress ( folly::SocketAddress & addr ) const

inline

Definition at line 519 of file HTTPTransaction.h.

References transport_.

Referenced by TEST_F().

                                                        {
     addr = transport_.getLocalAddress();
   }

const folly::SocketAddress& proxygen::HTTPTransaction::getLocalAddress ( ) const

inlinenoexcept

Definition at line 527 of file HTTPTransaction.h.

References transport_.

                    {
     return transport_.getLocalAddress();
   }

uint32_t proxygen::HTTPTransaction::getMaxDeferredSize ( )

inline

Definition at line 576 of file HTTPTransaction.h.

References folly::pushmi::operators::error(), uint16_t, and uint32_t.

Referenced by proxygen::HTTPSession::onEgressMessageFinished().

                                 {
     return maxDeferredIngress_;
   }

void proxygen::HTTPTransaction::getPeerAddress ( folly::SocketAddress & addr ) const

inline

Definition at line 523 of file HTTPTransaction.h.

References transport_.

                                                       {
     addr = transport_.getPeerAddress();
   }

const folly::SocketAddress& proxygen::HTTPTransaction::getPeerAddress ( ) const

inlinenoexcept

Definition at line 532 of file HTTPTransaction.h.

References transport_.

                    {
     return transport_.getPeerAddress();
   }

http2::PriorityUpdate proxygen::HTTPTransaction::getPriority ( ) const

inline

Definition at line 488 of file HTTPTransaction.h.

Referenced by TEST_F().

                                           {
     return priority_;
   }

bool proxygen::HTTPTransaction::getPriorityFallback ( ) const

inline

Definition at line 499 of file HTTPTransaction.h.

                                    {
     return priorityFallback_;
   }

bool proxygen::HTTPTransaction::getPrioritySampleSummary ( HTTPTransaction::PrioritySampleSummary & summary ) const

Definition at line 1536 of file HTTPTransaction.cpp.

References prioritySample_.

                                                            {
   if (prioritySample_) {
     prioritySample_->getSummary(summary);
     return true;
   }
   return false;
 }

std::tuple<uint64_t, uint64_t, double> proxygen::HTTPTransaction::getPrioritySummary ( ) const

inline

Definition at line 492 of file HTTPTransaction.h.

References std::tr1::make_tuple().

                                                                   {
     return std::make_tuple(
         insertDepth_,
         currentDepth_,
         egressCalls_ > 0 ? cumulativeRatio_ / egressCalls_ : 0);
   }

const std::set<HTTPCodec::StreamID>& proxygen::HTTPTransaction::getPushedTransactions ( ) const

inline

Get a set of server-pushed transactions associated with this transaction.

Definition at line 1071 of file HTTPTransaction.h.

Referenced by proxygen::HTTPSession::onAbort().

                                                                  {
     return pushedTransactions_;
   }

virtual const Window& proxygen::HTTPTransaction::getReceiveWindow ( ) const

inlinevirtual

Get the receive window of the transaction

Definition at line 572 of file HTTPTransaction.h.

                                                  {
     return recvWindow_;
   }

int32_t proxygen::HTTPTransaction::getRecvToAck ( ) const

Definition at line 1349 of file HTTPTransaction.cpp.

References recvToAck_.

                                             {
   return recvToAck_;
 }

uint32_t proxygen::HTTPTransaction::getSequenceNumber ( ) const

inline

Definition at line 471 of file HTTPTransaction.h.

Referenced by proxygen::HTTPSession::onEgressMessageFinished().

471 { return seqNo_; }

proxygen::HTTPTransaction::seqNo_

uint32_t seqNo_

Definition: HTTPTransaction.h:1360

HTTPSessionStats* proxygen::HTTPTransaction::getSessionStats ( ) const

inline

Definition at line 545 of file HTTPTransaction.h.

Referenced by proxygen::HTTPSession::createTransaction().

                                             {
     return stats_;
   }

const wangle::TransportInfo& proxygen::HTTPTransaction::getSetupTransportInfo ( ) const

inlinenoexcept

Definition at line 537 of file HTTPTransaction.h.

References transport_.

Referenced by proxygen::RequestHandlerAdaptor::getSetupTransportInfo().

                                                                     {
     return transport_.getSetupTransportInfo();
   }

const Transport& proxygen::HTTPTransaction::getTransport ( ) const

inline

Definition at line 473 of file HTTPTransaction.h.

References transport_.

473 { return transport_; }

proxygen::HTTPTransaction::transport_

Transport & transport_

Definition: HTTPTransaction.h:1362

Transport& proxygen::HTTPTransaction::getTransport ( )

inline

Definition at line 475 of file HTTPTransaction.h.

References transport_.

475 { return transport_; }

proxygen::HTTPTransaction::transport_

Transport & transport_

Definition: HTTPTransaction.h:1362

bool proxygen::HTTPTransaction::hasIdleTimeout ( ) const

inline

Does this transaction have an idle timeout set?

Definition at line 1033 of file HTTPTransaction.h.

                               {
     return transactionTimeout_.hasValue();
   }

bool proxygen::HTTPTransaction::hasPendingBody ( ) const

inline

Definition at line 1220 of file HTTPTransaction.h.

                               {
     return deferredEgressBody_.chainLength() > 0;
   }

bool proxygen::HTTPTransaction::hasPendingEOM ( ) const

inlineprivate

Definition at line 1289 of file HTTPTransaction.h.

Referenced by sendDeferredBody().

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

void proxygen::HTTPTransaction::incrementPendingByteEvents ( )

inline

HTTPTransaction will not detach until it has 0 pending byte events. If you call incrementPendingByteEvents, you must make a corresponding call to decrementPendingByteEvents or the transaction will never be destroyed.

Definition at line 1137 of file HTTPTransaction.h.

References max.

Referenced by TEST_F().

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

bool proxygen::HTTPTransaction::isDownstream ( ) const

inline

Definition at line 515 of file HTTPTransaction.h.

References proxygen::DOWNSTREAM.

Referenced by proxygen::HTTPSession::onMessageComplete().

                             {
     return direction_ == TransportDirection::DOWNSTREAM;
   }

bool proxygen::HTTPTransaction::isEgressComplete ( ) const

inline

Returns: true iff the egress EOM has been flushed to the socket.

Definition at line 753 of file HTTPTransaction.h.

Referenced by onDelayedDestroy(), onError(), onIngressTimeout(), and sendHeadersWithOptionalEOM().

                                 {
     return egressState_ == HTTPTransactionEgressSM::State::SendingDone;
   }

bool proxygen::HTTPTransaction::isEgressEOMQueued ( ) const

inline

Returns: true iff sendEOM() has been called, but the eom has not been flushed to the socket yet.

Definition at line 746 of file HTTPTransaction.h.

Referenced by notifyTransportPendingEgress(), and sendDeferredBody().

                                  {
     return egressState_ == HTTPTransactionEgressSM::State::EOMQueued;
   }

bool proxygen::HTTPTransaction::isEgressEOMSeen ( ) const

inline

Returns: true iff sendEOM() has been called.

Definition at line 768 of file HTTPTransaction.h.

                                {
     return isEgressEOMQueued() || isEgressComplete();
   }

bool proxygen::HTTPTransaction::isEgressPaused ( ) const

inline

Returns: true iff egress processing is paused for the handler

Definition at line 941 of file HTTPTransaction.h.

941 { return handlerEgressPaused_; }

proxygen::HTTPTransaction::handlerEgressPaused_

bool handlerEgressPaused_

Definition: HTTPTransaction.h:1470

bool proxygen::HTTPTransaction::isEgressStarted ( ) const

inline

Returns: true if egress has started on this transaction.

Definition at line 738 of file HTTPTransaction.h.

                                {
     return egressState_ != HTTPTransactionEgressSM::State::Start;
   }

bool proxygen::HTTPTransaction::isEnqueued ( ) const

inlineprivate

Definition at line 1282 of file HTTPTransaction.h.

Referenced by markEgressComplete(), notifyTransportPendingEgress(), onDelayedDestroy(), onWriteReady(), sendBody(), sendEOM(), and ~HTTPTransaction().

1282 { return queueHandle_->isEnqueued(); }

proxygen::HTTP2PriorityQueueBase::BaseNode::isEnqueued

virtual bool isEnqueued() const =0

proxygen::HTTPTransaction::queueHandle_

HTTP2PriorityQueueBase::Handle queueHandle_

Definition: HTTPTransaction.h:1406

bool proxygen::HTTPTransaction::isExpectingIngress ( ) const

private

Definition at line 483 of file HTTPTransaction.cpp.

References ingressPaused_, isExpectingWindowUpdate(), and isIngressEOMSeen().

Referenced by updateReadTimeout().

                                                {
   return (!ingressPaused_ &&
           (!isIngressEOMSeen() || isExpectingWindowUpdate()));
 }

bool proxygen::HTTPTransaction::isExpectingWindowUpdate ( ) const

private

Definition at line 479 of file HTTPTransaction.cpp.

References proxygen::Window::getSize(), sendWindow_, and useFlowControl_.

Referenced by isExpectingIngress(), onError(), onIngressTimeout(), and sendBodyNow().

                                                     {
   return (useFlowControl_ && sendWindow_.getSize() <= 0);
 }

bool proxygen::HTTPTransaction::isExTransaction ( ) const

inline

Definition at line 1015 of file HTTPTransaction.h.

                                {
     return exAttributes_.has_value();
   }

bool proxygen::HTTPTransaction::isFlowControlPaused ( ) const

inline

Returns: true iff egress processing is paused due to flow control to the handler

Definition at line 947 of file HTTPTransaction.h.

947 { return flowControlPaused_; }

proxygen::HTTPTransaction::flowControlPaused_

bool flowControlPaused_

Definition: HTTPTransaction.h:1469

bool proxygen::HTTPTransaction::isIngressComplete ( ) const

inline

Returns: true iff the handler has been notified of the ingress EOM.

Definition at line 724 of file HTTPTransaction.h.

Referenced by onDelayedDestroy(), onError(), processIngressBody(), processIngressChunkComplete(), processIngressChunkHeader(), processIngressEOM(), processIngressHeadersComplete(), processIngressTrailers(), processIngressUpgrade(), and resumeIngress().

                                  {
     return ingressState_ == HTTPTransactionIngressSM::State::ReceivingDone;
   }

bool proxygen::HTTPTransaction::isIngressEOMQueued ( ) const

inline

Returns: true iff the ingress EOM has been queued in HTTPTransaction but the handler has not yet been notified of this event.

Definition at line 717 of file HTTPTransaction.h.

                                   {
     return ingressState_ == HTTPTransactionIngressSM::State::EOMQueued;
   }

bool proxygen::HTTPTransaction::isIngressEOMSeen ( ) const

inline

Returns: true iff onIngressEOM() has been called.

Definition at line 731 of file HTTPTransaction.h.

Referenced by flushWindowUpdate(), isExpectingIngress(), onError(), onIngressBody(), onIngressEOM(), proxygen::HTTPSession::onPushMessageBegin(), and processIngressBody().

                                 {
     return isIngressEOMQueued() || isIngressComplete();
   }

bool proxygen::HTTPTransaction::isIngressPaused ( ) const

inline

Returns: true iff ingress processing is paused for the handler

Definition at line 905 of file HTTPTransaction.h.

References uint64_t.

Referenced by proxygen::HTTPSession::onExMessageBegin().

905 { return ingressPaused_; }

proxygen::HTTPTransaction::ingressPaused_

bool ingressPaused_

Definition: HTTPTransaction.h:1467

bool proxygen::HTTPTransaction::isIngressStarted ( ) const

inline

Returns: true if ingress has started on this transaction.

Definition at line 709 of file HTTPTransaction.h.

                                 {
     return ingressState_ != HTTPTransactionIngressSM::State::Start;
   }

bool proxygen::HTTPTransaction::isPrioritySampled ( ) const

inline

Definition at line 1195 of file HTTPTransaction.h.

References uint64_t.

Referenced by sendBodyNow().

                                  {
     return prioritySample_ != nullptr;
   }

bool proxygen::HTTPTransaction::isPushed ( ) const

inline

True if this transaction is a server push transaction

Definition at line 1011 of file HTTPTransaction.h.

Referenced by proxygen::HTTPSession::createTransaction(), proxygen::HTTPSession::decrementTransactionCount(), onIngressHeadersComplete(), proxygen::HTTPSession::onMessageBegin(), and sendHeadersWithOptionalEOM().

                         {
     return assocStreamId_.has_value();
   }

bool proxygen::HTTPTransaction::isRemoteInitiated ( ) const

inline

Returns: true iff the remote side initiated this transaction.

Definition at line 760 of file HTTPTransaction.h.

References proxygen::DOWNSTREAM, and proxygen::UPSTREAM.

Referenced by HTTPTransaction(), and proxygen::HTTPSession::onHeadersComplete().

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

bool proxygen::HTTPTransaction::isUnidirectional ( ) const

inline

Definition at line 1019 of file HTTPTransaction.h.

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

bool proxygen::HTTPTransaction::isUpstream ( ) const

inline

Definition at line 511 of file HTTPTransaction.h.

References proxygen::UPSTREAM.

Referenced by HTTPTransaction(), onIngressEOM(), onIngressHeadersComplete(), and sendAbort().

                           {
     return direction_ == TransportDirection::UPSTREAM;
   }

void proxygen::HTTPTransaction::markEgressComplete ( )

private

Causes isEgressComplete() to return true, removes any queued egress, and cancels the write timeout.

Definition at line 503 of file HTTPTransaction.cpp.

References folly::IOBufQueue::chainLength(), deferredEgressBody_, dequeue(), egressState_, int64_t, isEnqueued(), folly::IOBufQueue::move(), proxygen::HTTPTransaction::Transport::notifyEgressBodyBuffered(), and transport_.

Referenced by onEgressTimeout(), onError(), onIngressTimeout(), processIngressEOM(), and sendAbort().

                                          {
   VLOG(4) << "Marking egress complete on " << *this;
   if (deferredEgressBody_.chainLength() && isEnqueued()) {
     int64_t deferredEgressBodyBytes =
       folly::to<int64_t>(deferredEgressBody_.chainLength());
     transport_.notifyEgressBodyBuffered(-deferredEgressBodyBytes);
   }
   deferredEgressBody_.move();
   if (isEnqueued()) {
     dequeue();
   }
   egressState_ = HTTPTransactionEgressSM::State::SendingDone;
 }

void proxygen::HTTPTransaction::markIngressComplete ( )

private

Causes isIngressComplete() to return true, removes any queued ingress, and cancels the read timeout.

Definition at line 496 of file HTTPTransaction.cpp.

References folly::HHWheelTimer::Callback::cancelTimeout(), deferredIngress_, and ingressState_.

Referenced by onError(), onIngressTimeout(), and sendAbort().

                                           {
   VLOG(4) << "Marking ingress complete on " << *this;
   ingressState_ = HTTPTransactionIngressSM::State::ReceivingDone;
   deferredIngress_.reset();
   cancelTimeout();
 }

bool proxygen::HTTPTransaction::maybeDelayForRateLimit ( )

private

Definition at line 888 of file HTTPTransaction.cpp.

References count, egressLimitBytesPerMs_, egressRateLimited_, proxygen::getCurrentTime(), int64_t, proxygen::millisecondsBetween(), notifyTransportPendingEgress(), numLimitedBytesEgressed_, rateLimitCallback_, folly::HHWheelTimer::scheduleTimeout(), startRateLimit_, and timer_.

Referenced by sendDeferredBody().

                                              {
   if (egressLimitBytesPerMs_ <= 0) {
     // No rate limiting
     return false;
   }
 
   if (numLimitedBytesEgressed_ == 0) {
     // If we haven't egressed any bytes yet, don't delay.
     return false;
   }
 
   int64_t limitedDurationMs = (int64_t) millisecondsBetween(
     getCurrentTime(),
     startRateLimit_
   ).count();
 
   // Algebra!  Try to figure out the next time send where we'll
   // be allowed to send at least 1 full packet's worth.  The
   // formula we're using is:
   //   (bytesSoFar + packetSize) / (timeSoFar + delay) == targetRateLimit
   std::chrono::milliseconds requiredDelay(
     (
      ((int64_t)numLimitedBytesEgressed_ + kApproximateMTU) -
      ((int64_t)egressLimitBytesPerMs_ * limitedDurationMs)
     ) / (int64_t)egressLimitBytesPerMs_
   );
 
   if (requiredDelay.count() <= 0) {
     // No delay required
     return false;
   }
 
   if (requiredDelay > kRateLimitMaxDelay) {
     // The delay should never be this long
     VLOG(4) << "ratelim: Required delay too long (" << requiredDelay.count()
             << "ms), ignoring";
     return false;
   }
 
   // Delay required
 
   egressRateLimited_ = true;
 
   if (timer_) {
     timer_->scheduleTimeout(&rateLimitCallback_, requiredDelay);
   }
 
   notifyTransportPendingEgress();
   return true;
 }

bool proxygen::HTTPTransaction::mustQueueIngress ( ) const

private

Definition at line 1253 of file HTTPTransaction.cpp.

References deferredIngress_, and ingressPaused_.

Referenced by onIngressBody(), onIngressChunkComplete(), onIngressChunkHeader(), onIngressEOM(), onIngressHeadersComplete(), onIngressTrailers(), and onIngressUpgrade().

                                              {
   return ingressPaused_ || (deferredIngress_ && !deferredIngress_->empty());
 }

virtual bool proxygen::HTTPTransaction::needToBlockForReplaySafety ( ) const

inlinevirtual

Definition at line 1189 of file HTTPTransaction.h.

References int32_t, and transport_.

                                                   {
     return transport_.needToBlockForReplaySafety();
   }

virtual HTTPTransaction* proxygen::HTTPTransaction::newExTransaction	(	HTTPTransactionHandler *	handler,
		bool	unidirectional = `false`
	)

inlinevirtual

Create a new extended transaction associated with this transaction, and assign the given handler and priority.

Returns: the new transaction for pubsub, or nullptr if a new push transaction is impossible right now.

Definition at line 984 of file HTTPTransaction.h.

References transport_.

Referenced by proxygen::RequestHandlerAdaptor::newExMessage().

                                                                          {
     auto txn = transport_.newExTransaction(handler, id_, unidirectional);
     if (txn) {
       exTransactions_.insert(txn->getID());
     }
     return txn;
   }

virtual HTTPTransaction* proxygen::HTTPTransaction::newPushedTransaction ( HTTPPushTransactionHandler * handler )

inlinevirtual

Create a new pushed transaction associated with this transaction, and assign the given handler and priority.

Returns: the new transaction for the push, or nullptr if a new push transaction is impossible right now.

Definition at line 965 of file HTTPTransaction.h.

References transport_.

Referenced by proxygen::RequestHandlerAdaptor::newPushedResponse(), and TEST_F().

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

void proxygen::HTTPTransaction::notifyTransportPendingEgress ( )

private

Definition at line 1181 of file HTTPTransaction.cpp.

References folly::IOBufQueue::chainLength(), proxygen::HTTP2PriorityQueueBase::clearPendingEgress(), deferredEgressBody_, egressQueue_, egressRateLimited_, proxygen::Window::getSize(), folly::gen::guard(), int64_t, isEgressEOMQueued(), isEnqueued(), proxygen::HTTPTransaction::Transport::notifyEgressBodyBuffered(), proxygen::HTTPTransaction::Transport::notifyPendingEgress(), queueHandle_, sendWindow_, proxygen::HTTP2PriorityQueueBase::signalPendingEgress(), transport_, updateHandlerPauseState(), and useFlowControl_.

Referenced by maybeDelayForRateLimit(), onIngressSetSendWindow(), onIngressWindowUpdate(), rateLimitTimeoutExpired(), sendBody(), sendDeferredBody(), and sendEOM().

                                                    {
   DestructorGuard guard(this);
   if (!egressRateLimited_ &&
       (deferredEgressBody_.chainLength() > 0 ||
        isEgressEOMQueued()) &&
       (!useFlowControl_ || sendWindow_.getSize() > 0)) {
     // Egress isn't paused, we have something to send, and flow
     // control isn't blocking us.
     if (!isEnqueued()) {
       // Insert into the queue and let the session know we've got something
       egressQueue_.signalPendingEgress(queueHandle_);
       transport_.notifyPendingEgress();
       transport_.notifyEgressBodyBuffered(deferredEgressBody_.chainLength());
     }
   } else if (isEnqueued()) {
     // Nothing to send, or not allowed to send right now.
     int64_t deferredEgressBodyBytes =
       folly::to<int64_t>(deferredEgressBody_.chainLength());
     transport_.notifyEgressBodyBuffered(-deferredEgressBodyBytes);
     egressQueue_.clearPendingEgress(queueHandle_);
   }
   updateHandlerPauseState();
 }

void proxygen::HTTPTransaction::onDelayedDestroy ( bool delayed )

overrideprivatevirtual

Implement onDelayedDestroy in subclasses. onDelayedDestroy() is invoked when the object is potentially being destroyed.

Parameters

delayed This parameter is true if destruction was delayed because of a DestructorGuard object, or false if onDelayedDestroy() is being called directly from the destructor.

Implements folly::DelayedDestructionBase.

Definition at line 111 of file HTTPTransaction.cpp.

References deleting_, proxygen::HTTPTransaction::Transport::detach(), proxygen::HTTPTransactionHandler::detachTransaction(), proxygen::Window::getOutstanding(), handler_, isEgressComplete(), isEnqueued(), isIngressComplete(), proxygen::HTTPTransaction::Transport::notifyIngressBodyProcessed(), pendingByteEvents_, recvWindow_, transport_, and transportCallback_.

                                                    {
   if (!isEgressComplete() || !isIngressComplete() || isEnqueued()
       || pendingByteEvents_ > 0 || deleting_) {
     return;
   }
   VLOG(4) << "destroying transaction " << *this;
   deleting_ = true;
   if (handler_) {
     handler_->detachTransaction();
     handler_ = nullptr;
   }
   transportCallback_ = nullptr;
   const auto bytesBuffered = recvWindow_.getOutstanding();
   if (bytesBuffered) {
     transport_.notifyIngressBodyProcessed(bytesBuffered);
   }
   transport_.detach(this);
   (void)delayed; // prevent unused variable warnings
 }

void proxygen::HTTPTransaction::onDeltaSendWindowSize ( int32_t windowDelta )

private

void proxygen::HTTPTransaction::onEgressBodyFirstByte ( )

Invoked by the session when the first byte is flushed.

Definition at line 701 of file HTTPTransaction.cpp.

References proxygen::HTTPTransactionTransportCallback::firstByteFlushed(), g(), and transportCallback_.

Referenced by proxygen::HTTPSessionBase::handleLastByteEvents().

                                             {
   DestructorGuard g(this);
   if (transportCallback_) {
     transportCallback_->firstByteFlushed();
   }
 }

void proxygen::HTTPTransaction::onEgressBodyLastByte ( )

Invoked by the session when the last byte is flushed.

Definition at line 708 of file HTTPTransaction.cpp.

References g(), proxygen::HTTPTransactionTransportCallback::lastByteFlushed(), and transportCallback_.

Referenced by proxygen::HTTPSessionBase::handleLastByteEvents().

                                            {
   DestructorGuard g(this);
   if (transportCallback_) {
     transportCallback_->lastByteFlushed();
   }
 }

void proxygen::HTTPTransaction::onEgressHeaderFirstByte ( )

Invoked by the session when the first header byte is flushed.

Definition at line 694 of file HTTPTransaction.cpp.

References proxygen::HTTPTransactionTransportCallback::firstHeaderByteFlushed(), g(), and transportCallback_.

                                               {
   DestructorGuard g(this);
   if (transportCallback_) {
     transportCallback_->firstHeaderByteFlushed();
   }
 }

void proxygen::HTTPTransaction::onEgressLastByteAck ( std::chrono::milliseconds latency )

Invoked when the ACK_LATENCY event is delivered

Parameters

latency the time between the moment when the last byte was sent and the moment when we received the ACK from the client

Definition at line 722 of file HTTPTransaction.cpp.

References g(), proxygen::HTTPTransactionTransportCallback::lastByteAcked(), and transportCallback_.

                                                                        {
   DestructorGuard g(this);
   if (transportCallback_) {
     transportCallback_->lastByteAcked(latency);
   }
 }

void proxygen::HTTPTransaction::onEgressTimeout ( )

Invoked by the session when there is a timeout on the egress stream.

Definition at line 681 of file HTTPTransaction.cpp.

References proxygen::HTTPException::EGRESS, g(), handler_, id_, proxygen::kErrorTimeout, markEgressComplete(), onError(), and proxygen::Exception::setProxygenError().

                                       {
   DestructorGuard g(this);
   VLOG(4) << "egress timeout on " << *this;
   if (handler_) {
     HTTPException ex(HTTPException::Direction::EGRESS,
       folly::to<std::string>("egress timeout, streamID=", id_));
     ex.setProxygenError(kErrorTimeout);
     onError(ex);
   } else {
     markEgressComplete();
   }
 }

void proxygen::HTTPTransaction::onEgressTrackedByte ( )

Invoked by the session when the tracked byte is flushed.

Definition at line 715 of file HTTPTransaction.cpp.

References g(), proxygen::HTTPTransactionTransportCallback::trackedByteFlushed(), and transportCallback_.

                                           {
   DestructorGuard g(this);
   if (transportCallback_) {
     transportCallback_->trackedByteFlushed();
   }
 }

void proxygen::HTTPTransaction::onError ( const HTTPException & error )

Invoked by the session when there is an error (e.g., invalid syntax, TCP RST) in either the ingress or egress stream. Note that this message is processed immediately even if this transaction normally would queue ingress.

Parameters

error Details for the error. This exception also has information about whether the error applies to the ingress, egress, or both directions of the transaction

Definition at line 536 of file HTTPTransaction.cpp.

References aborted_, proxygen::HTTPException::EGRESS, proxygen::FLOW_CONTROL_ERROR, g(), proxygen::HTTPException::getCodecStatusCode(), proxygen::HTTPException::getDirection(), proxygen::Exception::getProxygenError(), handler_, proxygen::HTTPException::hasCodecStatusCode(), proxygen::HTTPException::INGRESS, proxygen::HTTPException::INGRESS_AND_EGRESS, ingressErrorSeen_, isEgressComplete(), isExpectingWindowUpdate(), isIngressComplete(), isIngressEOMSeen(), proxygen::kErrorStreamAbort, proxygen::kErrorWriteTimeout, markEgressComplete(), markIngressComplete(), proxygen::HTTPTransactionHandler::onError(), and sendAbort().

Referenced by proxygen::HTTPSessionBase::handleErrorDirectly(), proxygen::HTTPSession::onAbort(), onEgressTimeout(), proxygen::HTTPSession::onError(), onIngressBody(), onIngressEOM(), onIngressTimeout(), proxygen::HTTPSession::onMessageBegin(), sendBodyNow(), proxygen::HTTPSession::shutdownTransport(), TEST(), and validateIngressStateTransition().

                                                         {
   DestructorGuard g(this);
 
   const bool wasAborted = aborted_; // see comment below
   const bool wasEgressComplete = isEgressComplete();
   const bool wasIngressComplete = isIngressComplete();
   bool notify = (handler_);
   HTTPException::Direction direction = error.getDirection();
 
   if (direction == HTTPException::Direction::INGRESS &&
       isIngressEOMSeen() && isExpectingWindowUpdate()) {
     // we got an ingress error, we've seen the entire message, but we're
     // expecting more (window updates).  These aren't coming, convert to
     // INGRESS_AND_EGRESS
     VLOG(4) << "Converting ingress error to ingress+egress due to"
       " flow control, and aborting " << *this;
     direction = HTTPException::Direction::INGRESS_AND_EGRESS;
     sendAbort(ErrorCode::FLOW_CONTROL_ERROR);
   }
 
   if (error.getProxygenError() == kErrorStreamAbort) {
     DCHECK(error.getDirection() ==
            HTTPException::Direction::INGRESS_AND_EGRESS);
     aborted_ = true;
   } else if (error.hasCodecStatusCode()) {
     DCHECK(error.getDirection() ==
            HTTPException::Direction::INGRESS_AND_EGRESS);
     sendAbort(error.getCodecStatusCode());
   }
 
   switch (direction) {
     case HTTPException::Direction::INGRESS_AND_EGRESS:
       markEgressComplete();
       markIngressComplete();
       if (wasEgressComplete && wasIngressComplete &&
           // We mark egress complete before we get acknowledgement of the
           // write segment finishing successfully.
           // TODO: instead of using DestructorGuard hacks to keep txn around,
           // use an explicit callback function and set egress complete after
           // last byte flushes (or egress error occurs), see #3912823
           (error.getProxygenError() != kErrorWriteTimeout || wasAborted)) {
         notify = false;
       }
       break;
     case HTTPException::Direction::EGRESS:
       markEgressComplete();
       if (!wasEgressComplete && isIngressEOMSeen() && ingressErrorSeen_) {
         // we've already seen an ingress error but we ignored it, hoping the
         // handler would resume and read our queued EOM.  Now both sides are
         // dead and we need to kill this transaction.
         markIngressComplete();
       }
       if (wasEgressComplete) {
         notify = false;
       }
       break;
     case HTTPException::Direction::INGRESS:
       if (isIngressEOMSeen()) {
         // Not an error, for now
         ingressErrorSeen_ = true;
         return;
       }
       markIngressComplete();
       if (wasIngressComplete) {
         notify = false;
       }
       break;
   }
   if (notify && handler_) {
     // mark egress complete may result in handler detaching
     handler_->onError(error);
   }
 }

bool proxygen::HTTPTransaction::onExTransaction ( HTTPTransaction * txn )

Invoked by the session when a new ExTransaction arrives. The txn's handler will be notified and is responsible for installing a handler. If no handler is installed in the callback, the transaction will be aborted.

Definition at line 1279 of file HTTPTransaction.cpp.

References proxygen::ERROR, exTransactions_, g(), getControlStream(), getHandler(), getID(), handler_, id_, and proxygen::HTTPTransactionHandler::onExTransaction().

                                                             {
   DestructorGuard g(this);
   CHECK_EQ(*(exTxn->getControlStream()), id_);
   if (!handler_) {
     LOG(ERROR) << "Cannot add a exTxn to an unhandled txn";
     return false;
   }
   handler_->onExTransaction(exTxn);
   if (!exTxn->getHandler()) {
     LOG(ERROR) << "Failed to create a handler for ExTransaction";
     return false;
   }
   exTransactions_.insert(exTxn->getID());
   return true;
 }

void proxygen::HTTPTransaction::onGoaway ( ErrorCode code )

Invoked by the session when a GOAWAY frame is received. TODO: we may consider exposing the additional debug data here in the future.

Parameters

code	The error code received in the GOAWAY frame

Definition at line 610 of file HTTPTransaction.cpp.

References g(), handler_, and proxygen::HTTPTransactionHandler::onGoaway().

Referenced by proxygen::HTTPSession::onGoaway().

                                              {
   DestructorGuard g(this);
   VLOG(4) << "received GOAWAY notification on " << *this;
   // This callback can be received at any time and does not affect this
   // transaction's ingress or egress state machines. If it would have
   // affected this transaction's state, we would have received onError()
   // instead.
   if (handler_) {
     handler_->onGoaway(code);
   }
 }

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

Invoked by the session when some or all of the ingress entity-body has been parsed.

Definition at line 217 of file HTTPTransaction.cpp.

References proxygen::HTTPEvent::BODY, proxygen::HTTPTransactionTransportCallback::bodyBytesReceived(), checkCreateDeferredIngress(), folly::IOBuf::computeChainDataLength(), deferredIngress_, proxygen::ERROR, expectedContentLengthRemaining_, proxygen::FLOW_CONTROL_ERROR, FOLLY_SCOPED_TRACE_SECTION, proxygen::Window::free(), g(), proxygen::Window::getCapacity(), proxygen::Window::getOutstanding(), handler_, folly::Optional< Value >::hasValue(), id_, proxygen::HTTPException::INGRESS, isIngressEOMSeen(), proxygen::kErrorParseBody, folly::gen::move, mustQueueIngress(), onError(), processIngressBody(), recvToAck_, recvWindow_, proxygen::Window::reserve(), sendAbort(), proxygen::Exception::setProxygenError(), proxygen::STREAM_CLOSED, transportCallback_, useFlowControl_, validateIngressStateTransition(), and folly::Optional< Value >::value().

Referenced by proxygen::HTTPSessionBase::onBodyImpl(), and DownstreamTransactionTest::setupRequestResponseFlow().

                                                       {
   FOLLY_SCOPED_TRACE_SECTION("HTTPTransaction - onIngressBody");
   DestructorGuard g(this);
   if (isIngressEOMSeen()) {
     sendAbort(ErrorCode::STREAM_CLOSED);
     return;
   }
   auto len = chain->computeChainDataLength();
   if (len == 0) {
     return;
   }
   if (!validateIngressStateTransition(
         HTTPTransactionIngressSM::Event::onBody)) {
     return;
   }
   if (expectedContentLengthRemaining_.hasValue()) {
     if (expectedContentLengthRemaining_.value() >= len) {
       expectedContentLengthRemaining_ =
         expectedContentLengthRemaining_.value() - len;
     } else {
       auto errorMsg = folly::to<std::string>(
           "Content-Length/body mismatch: received=",
           len,
           " expecting no more than ",
           expectedContentLengthRemaining_.value());
       LOG(ERROR) << errorMsg << " " << *this;
       if (handler_) {
         HTTPException ex(HTTPException::Direction::INGRESS, errorMsg);
         ex.setProxygenError(kErrorParseBody);
         onError(ex);
       }
       return;
     }
   }
   if (transportCallback_) {
     transportCallback_->bodyBytesReceived(len);
   }
   // register the bytes in the receive window
   if (!recvWindow_.reserve(len + padding, useFlowControl_)) {
     LOG(ERROR) << "recvWindow_.reserve failed with len=" << len
                << " padding=" << padding
                << " capacity=" << recvWindow_.getCapacity()
                << " outstanding=" << recvWindow_.getOutstanding()
                << " " << *this ;
     sendAbort(ErrorCode::FLOW_CONTROL_ERROR);
     return;
   } else {
     CHECK(recvWindow_.free(padding));
     recvToAck_ += padding;
   }
   if (mustQueueIngress()) {
     checkCreateDeferredIngress();
     deferredIngress_->emplace(id_, HTTPEvent::Type::BODY,
                               std::move(chain));
     VLOG(4) << "Queued ingress event of type " << HTTPEvent::Type::BODY
             << " size=" << len << " " << *this;
   } else {
     CHECK(recvWindow_.free(len));
     processIngressBody(std::move(chain), len);
   }
 }

void proxygen::HTTPTransaction::onIngressChunkComplete ( )

Invoked by the session when the CRLF terminating a chunk has been parsed.

Definition at line 336 of file HTTPTransaction.cpp.

References checkCreateDeferredIngress(), proxygen::HTTPEvent::CHUNK_COMPLETE, deferredIngress_, id_, mustQueueIngress(), processIngressChunkComplete(), and validateIngressStateTransition().

Referenced by proxygen::HTTPSession::onChunkComplete().

                                              {
   if (!validateIngressStateTransition(
         HTTPTransactionIngressSM::Event::onChunkComplete)) {
     return;
   }
   if (mustQueueIngress()) {
     checkCreateDeferredIngress();
     deferredIngress_->emplace(id_, HTTPEvent::Type::CHUNK_COMPLETE);
     VLOG(4) << "Queued ingress event of type "
             << HTTPEvent::Type::CHUNK_COMPLETE << " " << *this;
   } else {
     processIngressChunkComplete();
   }
 }

void proxygen::HTTPTransaction::onIngressChunkHeader ( size_t length )

Invoked by the session when a chunk header has been parsed.

Definition at line 310 of file HTTPTransaction.cpp.

References checkCreateDeferredIngress(), proxygen::HTTPEvent::CHUNK_HEADER, deferredIngress_, id_, mustQueueIngress(), processIngressChunkHeader(), and validateIngressStateTransition().

Referenced by proxygen::HTTPSession::onChunkHeader().

                                                         {
   if (!validateIngressStateTransition(
         HTTPTransactionIngressSM::Event::onChunkHeader)) {
     return;
   }
   if (mustQueueIngress()) {
     checkCreateDeferredIngress();
     deferredIngress_->emplace(id_, HTTPEvent::Type::CHUNK_HEADER, length);
     VLOG(4) << "Queued ingress event of type " << HTTPEvent::Type::CHUNK_HEADER
             << " size=" << length << " " << *this;
   } else {
     processIngressChunkHeader(length);
   }
 }

void proxygen::HTTPTransaction::onIngressEOM ( )

Invoked by the session when the ingress message is complete.

Definition at line 414 of file HTTPTransaction.cpp.

References checkCreateDeferredIngress(), deferredIngress_, proxygen::ERROR, expectedContentLengthRemaining_, extraResponseExpected(), handler_, folly::Optional< Value >::hasValue(), id_, proxygen::HTTPException::INGRESS, isIngressEOMSeen(), isUpstream(), proxygen::kErrorParseBody, proxygen::HTTPEvent::MESSAGE_COMPLETE, mustQueueIngress(), onError(), processIngressEOM(), sendAbort(), proxygen::Exception::setProxygenError(), proxygen::STREAM_CLOSED, updateReadTimeout(), validateIngressStateTransition(), and folly::Optional< Value >::value().

Referenced by proxygen::HTTPSession::onMessageComplete(), and DownstreamTransactionTest::setupRequestResponseFlow().

                                    {
   if (isIngressEOMSeen()) {
     // This can happen when HTTPSession calls onIngressEOF()
     sendAbort(ErrorCode::STREAM_CLOSED);
     return;
   }
   if (expectedContentLengthRemaining_.hasValue() &&
       expectedContentLengthRemaining_.value() > 0) {
     auto errorMsg = folly::to<std::string>(
         "Content-Length/body mismatch: expecting another ",
         expectedContentLengthRemaining_.value());
     LOG(ERROR) << errorMsg << " " << *this;
     if (handler_) {
       HTTPException ex(HTTPException::Direction::INGRESS, errorMsg);
       ex.setProxygenError(kErrorParseBody);
       onError(ex);
     }
     return;
   }
 
   // TODO: change the codec to not give an EOM callback after a 100 response?
   // We could then delete the below 'if'
   if (isUpstream() && extraResponseExpected()) {
     VLOG(4) << "Ignoring EOM on initial 100 response on " << *this;
     return;
   }
   if (!validateIngressStateTransition(
         HTTPTransactionIngressSM::Event::onEOM)) {
     return;
   }
   // We need to update the read timeout here.  We're not likely to be
   // expecting any more ingress, and the timer should be cancelled
   // immediately.  If we are expecting more, this will reset the timer.
   updateReadTimeout();
   if (mustQueueIngress()) {
     checkCreateDeferredIngress();
     deferredIngress_->emplace(id_, HTTPEvent::Type::MESSAGE_COMPLETE);
     VLOG(4) << "Queued ingress event of type "
             << HTTPEvent::Type::MESSAGE_COMPLETE << " " << *this;
   } else {
     processIngressEOM();
   }
 }

void proxygen::HTTPTransaction::onIngressHeadersComplete ( std::unique_ptr< HTTPMessage > msg )

Invoked by the session when the ingress headers are complete

Definition at line 158 of file HTTPTransaction.cpp.

References checkCreateDeferredIngress(), proxygen::CONNECT, deferredIngress_, proxygen::ERROR, expectedContentLengthRemaining_, g(), proxygen::HTTPTransaction::Transport::getCodec(), proxygen::HTTPCodec::getHPACKTableInfo(), proxygen::HTTPCodec::getProtocol(), proxygen::HEAD, proxygen::HTTPTransactionTransportCallback::headerBytesReceived(), proxygen::HTTPEvent::HEADERS_COMPLETE, headRequest_, proxygen::HTTP_2, proxygen::HTTP_HEADER_CONTENT_LENGTH, id_, isPushed(), isUpstream(), lastResponseStatus_, folly::gen::move, mustQueueIngress(), processIngressHeadersComplete(), proxygen::RFC2616::responseBodyMustBeEmpty(), seqNo_, transport_, transportCallback_, updateIngressHPACKTableInfo(), and validateIngressStateTransition().

                                   {
   DestructorGuard g(this);
   msg->setSeqNo(seqNo_);
   if (isUpstream() && !isPushed() && msg->isResponse()) {
     lastResponseStatus_ = msg->getStatusCode();
   }
   if (!validateIngressStateTransition(
           HTTPTransactionIngressSM::Event::onHeaders)) {
     return;
   }
   if (msg->isRequest()) {
     headRequest_ = (msg->getMethod() == HTTPMethod::HEAD);
   }
 
   if ((msg->isRequest() && msg->getMethod() != HTTPMethod::CONNECT) ||
       (msg->isResponse() && !headRequest_ &&
        !RFC2616::responseBodyMustBeEmpty(msg->getStatusCode()))) {
     // CONNECT payload has no defined semantics
     const auto& contentLen =
         msg->getHeaders().getSingleOrEmpty(HTTP_HEADER_CONTENT_LENGTH);
     if (!contentLen.empty()) {
       try {
         expectedContentLengthRemaining_ = folly::to<uint64_t>(contentLen);
       } catch (const folly::ConversionError& ex) {
         LOG(ERROR) << "Invalid content-length: " << contentLen
                    << ", ex=" << ex.what() << *this;
       }
     }
   }
   if (transportCallback_) {
     transportCallback_->headerBytesReceived(msg->getIngressHeaderSize());
   }
   if (transport_.getCodec().getProtocol() == CodecProtocol::HTTP_2) {
     updateIngressHPACKTableInfo(transport_.getCodec().getHPACKTableInfo());
   }
   if (mustQueueIngress()) {
     checkCreateDeferredIngress();
     deferredIngress_->emplace(id_, HTTPEvent::Type::HEADERS_COMPLETE,
                              std::move(msg));
     VLOG(4) << "Queued ingress event of type "
             << HTTPEvent::Type::HEADERS_COMPLETE << " " << *this;
   } else {
     processIngressHeadersComplete(std::move(msg));
   }
 }

void proxygen::HTTPTransaction::onIngressSetSendWindow ( uint32_t newWindowSize )

Invoked by the session when the remote endpoint signals that we should change our send window. This is only for versions of HTTP that support per transaction flow control.

Definition at line 665 of file HTTPTransaction.cpp.

References proxygen::ERROR, proxygen::FLOW_CONTROL_ERROR, proxygen::Window::getCapacity(), proxygen::Window::getOutstanding(), notifyTransportPendingEgress(), sendAbort(), sendWindow_, proxygen::Window::setCapacity(), updateReadTimeout(), and useFlowControl_.

Referenced by proxygen::HTTPSession::onSetSendWindow().

                                                                          {
   if (!useFlowControl_) {
     return;
   }
   updateReadTimeout();
   if (sendWindow_.setCapacity(newWindowSize)) {
     notifyTransportPendingEgress();
   } else {
     LOG(ERROR) << "sendWindow_.setCapacity failed with newWindowSize="
                << newWindowSize << " capacity=" << sendWindow_.getCapacity()
                << " outstanding=" << sendWindow_.getOutstanding()
                << " " << *this;
     sendAbort(ErrorCode::FLOW_CONTROL_ERROR);
   }
 }

void proxygen::HTTPTransaction::onIngressTimeout ( )

Invoked by the session when there is a timeout on the ingress stream. Note that each transaction has its own timer but the session is the effective target of the timer.

Definition at line 622 of file HTTPTransaction.cpp.

References g(), handler_, id_, proxygen::HTTPException::INGRESS, proxygen::HTTPException::INGRESS_AND_EGRESS, isEgressComplete(), isExpectingWindowUpdate(), proxygen::kErrorTimeout, proxygen::kErrorWriteTimeout, markEgressComplete(), markIngressComplete(), onError(), pauseIngress(), proxygen::PROTOCOL_ERROR, proxygen::HTTPException::setCodecStatusCode(), and proxygen::Exception::setProxygenError().

                                        {
   DestructorGuard g(this);
   VLOG(4) << "ingress timeout on " << *this;
   pauseIngress();
   bool windowUpdateTimeout = !isEgressComplete() && isExpectingWindowUpdate();
   if (handler_) {
     if (windowUpdateTimeout) {
       HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS,
           folly::to<std::string>("ingress timeout, streamID=", id_));
       ex.setProxygenError(kErrorWriteTimeout);
       // This is a protocol error
       ex.setCodecStatusCode(ErrorCode::PROTOCOL_ERROR);
       onError(ex);
     } else {
       HTTPException ex(HTTPException::Direction::INGRESS,
           folly::to<std::string>("ingress timeout, streamID=", id_));
       ex.setProxygenError(kErrorTimeout);
       onError(ex);
     }
   } else {
     markIngressComplete();
     markEgressComplete();
   }
 }

void proxygen::HTTPTransaction::onIngressTrailers ( std::unique_ptr< HTTPHeaders > trailers )

Invoked by the session when the ingress trailers have been parsed.

Definition at line 362 of file HTTPTransaction.cpp.

References checkCreateDeferredIngress(), deferredIngress_, id_, folly::gen::move, mustQueueIngress(), processIngressTrailers(), proxygen::HTTPEvent::TRAILERS_COMPLETE, and validateIngressStateTransition().

Referenced by proxygen::HTTPSession::onTrailersComplete().

                                                                         {
   if (!validateIngressStateTransition(
         HTTPTransactionIngressSM::Event::onTrailers)) {
     return;
   }
   if (mustQueueIngress()) {
     checkCreateDeferredIngress();
     deferredIngress_->emplace(id_, HTTPEvent::Type::TRAILERS_COMPLETE,
         std::move(trailers));
     VLOG(4) << "Queued ingress event of type "
             << HTTPEvent::Type::TRAILERS_COMPLETE << " " << *this;
   } else {
     processIngressTrailers(std::move(trailers));
   }
 }

void proxygen::HTTPTransaction::onIngressUpgrade ( UpgradeProtocol protocol )

Invoked by the session when the session and transaction need to be upgraded to a different protocol

Definition at line 389 of file HTTPTransaction.cpp.

References checkCreateDeferredIngress(), deferredIngress_, id_, mustQueueIngress(), processIngressUpgrade(), proxygen::HTTPEvent::UPGRADE, and validateIngressStateTransition().

Referenced by proxygen::HTTPSession::onMessageComplete().

                                                                {
   if (!validateIngressStateTransition(
         HTTPTransactionIngressSM::Event::onUpgrade)) {
     return;
   }
   if (mustQueueIngress()) {
     checkCreateDeferredIngress();
     deferredIngress_->emplace(id_, HTTPEvent::Type::UPGRADE, protocol);
     VLOG(4) << "Queued ingress event of type " << HTTPEvent::Type::UPGRADE
             << " " << *this;
   } else {
     processIngressUpgrade(protocol);
   }
 }

void proxygen::HTTPTransaction::onIngressWindowUpdate ( uint32_t amount )

Invoked by the session when the remote endpoint of this transaction signals that it has consumed 'amount' bytes. This is only for versions of HTTP that support per transaction flow control.

Definition at line 647 of file HTTPTransaction.cpp.

References proxygen::ERROR, proxygen::FLOW_CONTROL_ERROR, proxygen::Window::free(), g(), proxygen::Window::getCapacity(), proxygen::Window::getOutstanding(), notifyTransportPendingEgress(), sendAbort(), sendWindow_, updateReadTimeout(), and useFlowControl_.

Referenced by proxygen::HTTPSession::onWindowUpdate().

                                                                  {
   if (!useFlowControl_) {
     return;
   }
   DestructorGuard g(this);
   VLOG(4) << "Remote side ack'd " << amount << " bytes " << *this ;
   updateReadTimeout();
   if (sendWindow_.free(amount)) {
     notifyTransportPendingEgress();
   } else {
     LOG(ERROR) << "sendWindow_.free failed with amount=" << amount
                << " capacity=" << sendWindow_.getCapacity()
                << " outstanding=" << sendWindow_.getOutstanding()
                << " " << *this;
     sendAbort(ErrorCode::FLOW_CONTROL_ERROR);
   }
 }

void proxygen::HTTPTransaction::onPriorityUpdate ( const http2::PriorityUpdate & priority )

Notify of priority change, will not generate a PRIORITY frame

Definition at line 1374 of file HTTPTransaction.cpp.

References currentDepth_, egressQueue_, priority_, priorityFallback_, queueHandle_, proxygen::http2::PriorityUpdate::streamDependency, and proxygen::HTTP2PriorityQueueBase::updatePriority().

Referenced by updateAndSendPriority().

                                                                           {
   priority_ = priority;
 
   queueHandle_ = egressQueue_.updatePriority(
       queueHandle_,
       priority_,
       &currentDepth_);
   if(priority_.streamDependency != 0 && currentDepth_ == 1) {
     priorityFallback_ = true;
   }
 }

bool proxygen::HTTPTransaction::onPushedTransaction ( HTTPTransaction * txn )

Invoked by the session (upstream only) when a new pushed transaction arrives. The txn's handler will be notified and is responsible for installing a handler. If no handler is installed in the callback, the pushed transaction will be aborted.

Definition at line 1263 of file HTTPTransaction.cpp.

References assocStreamId_, g(), getHandler(), getID(), handler_, id_, proxygen::HTTPTransactionHandler::onPushedTransaction(), and pushedTransactions_.

Referenced by proxygen::HTTPSession::onPushMessageBegin().

                                                                   {
   DestructorGuard g(this);
   CHECK_EQ(*pushTxn->assocStreamId_, id_);
   if (!handler_) {
     VLOG(4) << "Cannot add a pushed txn to an unhandled txn";
     return false;
   }
   handler_->onPushedTransaction(pushTxn);
   if (!pushTxn->getHandler()) {
     VLOG(4) << "Failed to create a handler for push transaction";
     return false;
   }
   pushedTransactions_.insert(pushTxn->getID());
   return true;
 }

bool proxygen::HTTPTransaction::onWriteReady	(	uint32_t	maxEgress,
		double	ratio
	)

Notify this transaction that it is ok to egress. Returns true if there is additional pending egress

Definition at line 801 of file HTTPTransaction.cpp.

References cumulativeRatio_, egressCalls_, g(), isEnqueued(), prioritySample_, sendDeferredBody(), and updateRelativeWeight().

Referenced by DownstreamTransactionTest::setupRequestResponseFlow().

                                                                          {
   DestructorGuard g(this);
   DCHECK(isEnqueued());
   if (prioritySample_) {
     updateRelativeWeight(ratio);
   }
   cumulativeRatio_ += ratio;
   egressCalls_++;
   sendDeferredBody(maxEgress);
   return isEnqueued();
 }

HTTPTransaction& proxygen::HTTPTransaction::operator= ( const HTTPTransaction & )

privatedelete

void proxygen::HTTPTransaction::pauseEgress ( )

Pause egress generation. HTTPTransaction may call its Handler's onEgressPaused() method if there is a state change as a result of this call.

On receiving onEgressPaused(), the Handler should make a best effort to stop invoking the HTTPTransaction's egress generating methods. If the Handler does invoke any of those methods while the transaction is paused, however, the transaction will forward them anyway, unless it is a body event. If flow control is enabled, body events will be buffered for later transmission when egress is unpaused.

Definition at line 1150 of file HTTPTransaction.cpp.

References egressPaused_, g(), and updateHandlerPauseState().

Referenced by proxygen::HTTPSession::resumeTransactions(), and proxygen::HTTPSession::updateWriteBufSize().

                                   {
   VLOG(4) << "asked to pause egress " << *this ;
   DestructorGuard g(this);
   if (egressPaused_) {
     VLOG(4) << "egress already paused " << *this ;
     return;
   }
   egressPaused_ = true;
   updateHandlerPauseState();
 }

void proxygen::HTTPTransaction::pauseIngress ( )

virtual

Pause ingress processing. Upon pause, the HTTPTransaction will call its Transport's pauseIngress() method. The Transport should make a best effort to stop invoking the HTTPTransaction's onIngress* callbacks. If the Transport does invoke any of those methods while the transaction is paused, however, the transaction will queue the ingress events and data and delay delivery to the Handler until the transaction is unpaused.

Definition at line 1072 of file HTTPTransaction.cpp.

References folly::HHWheelTimer::Callback::cancelTimeout(), g(), ingressPaused_, proxygen::HTTPTransaction::Transport::pauseIngress(), and transport_.

Referenced by ProxyService::ProxyHandler::onEgressPaused(), onIngressTimeout(), proxygen::RequestHandlerAdaptor::pauseIngress(), and TEST_F().

                                    {
   VLOG(4)<< "pauseIngress request " << *this;
   DestructorGuard g(this);
   if (ingressPaused_) {
     VLOG(4) << "can't pause ingress; ingressPaused=" << ingressPaused_;
     return;
   }
   ingressPaused_ = true;
   cancelTimeout();
   transport_.pauseIngress(this);
 }

void proxygen::HTTPTransaction::processIngressBody	(	std::unique_ptr< folly::IOBuf >	chain,
		size_t	len
	)

private

Definition at line 280 of file HTTPTransaction.cpp.

References aborted_, flushWindowUpdate(), FOLLY_SCOPED_TRACE_SECTION, g(), proxygen::Window::getCapacity(), handler_, proxygen::HTTPTransaction::Transport::isDraining(), isIngressComplete(), isIngressEOMSeen(), folly::gen::move, proxygen::HTTPTransaction::Transport::notifyIngressBodyProcessed(), proxygen::HTTPTransactionHandler::onBody(), recvToAck_, recvWindow_, refreshTimeout(), transport_, uint32_t, and useFlowControl_.

Referenced by onIngressBody(), and resumeIngress().

                                                                             {
   FOLLY_SCOPED_TRACE_SECTION("HTTPTransaction - processIngressBody");
   DestructorGuard g(this);
   if (aborted_) {
     return;
   }
   refreshTimeout();
   transport_.notifyIngressBodyProcessed(len);
   if (handler_) {
     if (!isIngressComplete()) {
       handler_->onBody(std::move(chain));
     }
 
     if (useFlowControl_ && !isIngressEOMSeen()) {
       recvToAck_ += len;
       if (recvToAck_ > 0) {
         uint32_t divisor = 2;
         if (transport_.isDraining()) {
           // only send window updates for draining transports when window is
           // closed
           divisor = 1;
         }
         if (uint32_t(recvToAck_) >= (recvWindow_.getCapacity() / divisor)) {
           flushWindowUpdate();
         }
       }
     } // else don't care about window updates
   }
 }

void proxygen::HTTPTransaction::processIngressChunkComplete ( )

private

Definition at line 351 of file HTTPTransaction.cpp.

References aborted_, g(), handler_, isIngressComplete(), proxygen::HTTPTransactionHandler::onChunkComplete(), and refreshTimeout().

Referenced by onIngressChunkComplete(), and resumeIngress().

                                                   {
   DestructorGuard g(this);
   if (aborted_) {
     return;
   }
   refreshTimeout();
   if (handler_ && !isIngressComplete()) {
     handler_->onChunkComplete();
   }
 }

void proxygen::HTTPTransaction::processIngressChunkHeader ( size_t length )

private

Definition at line 325 of file HTTPTransaction.cpp.

References aborted_, g(), handler_, isIngressComplete(), proxygen::HTTPTransactionHandler::onChunkHeader(), and refreshTimeout().

Referenced by onIngressChunkHeader(), and resumeIngress().

                                                              {
   DestructorGuard g(this);
   if (aborted_) {
     return;
   }
   refreshTimeout();
   if (handler_ && !isIngressComplete()) {
     handler_->onChunkHeader(length);
   }
 }

void proxygen::HTTPTransaction::processIngressEOM ( )

private

Definition at line 458 of file HTTPTransaction.cpp.

References aborted_, g(), handler_, isIngressComplete(), markEgressComplete(), proxygen::HTTPTransactionHandler::onEOM(), updateReadTimeout(), and validateIngressStateTransition().

Referenced by onIngressEOM(), and resumeIngress().

                                         {
   DestructorGuard g(this);
   if (aborted_) {
     return;
   }
   VLOG(4) << "ingress EOM on " << *this;
   const bool wasComplete = isIngressComplete();
   if (!validateIngressStateTransition(
         HTTPTransactionIngressSM::Event::eomFlushed)) {
     return;
   }
   if (handler_) {
     if (!wasComplete) {
       handler_->onEOM();
     }
   } else {
     markEgressComplete();
   }
   updateReadTimeout();
 }

void proxygen::HTTPTransaction::processIngressHeadersComplete ( std::unique_ptr< HTTPMessage > msg )

private

Definition at line 205 of file HTTPTransaction.cpp.

References aborted_, g(), handler_, isIngressComplete(), folly::gen::move, proxygen::HTTPTransactionHandler::onHeadersComplete(), and refreshTimeout().

Referenced by onIngressHeadersComplete(), and resumeIngress().

                                     {
   DestructorGuard g(this);
   if (aborted_) {
     return;
   }
   refreshTimeout();
   if (handler_ && !isIngressComplete()) {
     handler_->onHeadersComplete(std::move(msg));
   }
 }

void proxygen::HTTPTransaction::processIngressTrailers ( std::unique_ptr< HTTPHeaders > trailers )

private

Definition at line 378 of file HTTPTransaction.cpp.

References aborted_, g(), handler_, isIngressComplete(), folly::gen::move, proxygen::HTTPTransactionHandler::onTrailers(), and refreshTimeout().

Referenced by onIngressTrailers(), and resumeIngress().

                                                                              {
   DestructorGuard g(this);
   if (aborted_) {
     return;
   }
   refreshTimeout();
   if (handler_ && !isIngressComplete()) {
     handler_->onTrailers(std::move(trailers));
   }
 }

void proxygen::HTTPTransaction::processIngressUpgrade ( UpgradeProtocol protocol )

private

Definition at line 404 of file HTTPTransaction.cpp.

References aborted_, g(), handler_, isIngressComplete(), and proxygen::HTTPTransactionHandler::onUpgrade().

Referenced by onIngressUpgrade(), and resumeIngress().

                                                                     {
   DestructorGuard g(this);
   if (aborted_) {
     return;
   }
   if (handler_ && !isIngressComplete()) {
     handler_->onUpgrade(protocol);
   }
 }

void proxygen::HTTPTransaction::rateLimitTimeoutExpired ( )

private

Definition at line 939 of file HTTPTransaction.cpp.

References egressRateLimited_, and notifyTransportPendingEgress().

                                               {
   egressRateLimited_ = false;
   notifyTransportPendingEgress();
 }

void proxygen::HTTPTransaction::refreshTimeout ( )

inline

Schedule or refresh the timeout for this transaction

Definition at line 1100 of file HTTPTransaction.h.

References timer_.

Referenced by HTTPTransaction(), processIngressBody(), processIngressChunkComplete(), processIngressChunkHeader(), processIngressHeadersComplete(), processIngressTrailers(), proxygen::RequestHandlerAdaptor::refreshTimeout(), setIdleTimeout(), and updateReadTimeout().

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

void proxygen::HTTPTransaction::removeExTransaction ( HTTPCodec::StreamID exStreamId )

inline

Remove the exTxn ID from the control stream txn.

Definition at line 1093 of file HTTPTransaction.h.

Referenced by proxygen::HTTPSession::detach().

                                                          {
     exTransactions_.erase(exStreamId);
   }

void proxygen::HTTPTransaction::removePushedTransaction ( HTTPCodec::StreamID pushStreamId )

inline

Remove the pushed txn ID from the set of pushed txns associated with this txn.

Definition at line 1086 of file HTTPTransaction.h.

Referenced by proxygen::HTTPSession::detach().

                                                                {
     pushedTransactions_.erase(pushStreamId);
   }

virtual void proxygen::HTTPTransaction::removeWaitingForReplaySafety ( folly::AsyncTransport::ReplaySafetyCallback * callback )

inlinevirtual

Remove a callback waiting for replay protection (if it was canceled).

Definition at line 1184 of file HTTPTransaction.h.

References transport_.

                                                          {
     transport_.removeWaitingForReplaySafety(callback);
   }

void proxygen::HTTPTransaction::reset	(	bool	useFlowControl,
		uint32_t	receiveInitialWindowSize,
		uint32_t	receiveStreamWindowSize,
		uint32_t	sendInitialWindowSize
	)

Definition at line 148 of file HTTPTransaction.cpp.

References recvWindow_, sendWindow_, proxygen::Window::setCapacity(), setReceiveWindow(), and useFlowControl_.

Referenced by proxygen::HTTPSession::onNativeProtocolUpgradeImpl().

                                                             {
   useFlowControl_ = useFlowControl;
   recvWindow_.setCapacity(receiveInitialWindowSize);
   setReceiveWindow(receiveStreamWindowSize);
   sendWindow_.setCapacity(sendInitialWindowSize);
 }

void proxygen::HTTPTransaction::resumeEgress ( )

Resume egress generation. The Handler's onEgressResumed() will not be invoked if the HTTP/2 send window is full or there is too much buffered egress data on this transaction already. In that case, once the send window is not full or the buffer usage decreases, the handler will finally get onEgressResumed().

Definition at line 1161 of file HTTPTransaction.cpp.

References egressPaused_, g(), and updateHandlerPauseState().

                                    {
   VLOG(4) << "asked to resume egress" << *this;
   DestructorGuard g(this);
   if (!egressPaused_) {
     VLOG(4) << "egress already not paused" << *this;
     return;
   }
   egressPaused_ = false;
   updateHandlerPauseState();
 }

void proxygen::HTTPTransaction::resumeIngress ( )

virtual

Resume ingress processing. Only useful after a call to pauseIngress().

Definition at line 1084 of file HTTPTransaction.cpp.

Referenced by ProxyService::ProxyHandler::onEgressResumed(), proxygen::RequestHandlerAdaptor::resumeIngress(), and TEST_F().

                                     {
   VLOG(4) << "resumeIngress request " << *this;
   DestructorGuard g(this);
   if (!ingressPaused_ || isIngressComplete()) {
     VLOG(4) << "can't resume ingress, ingressPaused=" << ingressPaused_
             << ", ingressComplete=" << isIngressComplete()
             << ", inResume_=" << inResume_ << " " << *this;
     return;
   }
   ingressPaused_ = false;
   transport_.resumeIngress(this);
   if (inResume_) {
     VLOG(4) << "skipping recursive resume loop " << *this;
     return;
   }
   inResume_ = true;
 
   if (deferredIngress_ && (maxDeferredIngress_ <= deferredIngress_->size())) {
     maxDeferredIngress_ = deferredIngress_->size();
   }
 
   // Process any deferred ingress callbacks
   // Note: we recheck the ingressPaused_ state because a callback
   // invoked by the resumeIngress() call above could have re-paused
   // the transaction.
   while (!ingressPaused_ && deferredIngress_ && !deferredIngress_->empty()) {
     HTTPEvent& callback(deferredIngress_->front());
     VLOG(5) << "Processing deferred ingress callback of type "
             << callback.getEvent() << " " << *this;
     switch (callback.getEvent()) {
       case HTTPEvent::Type::MESSAGE_BEGIN:
         LOG(FATAL) << "unreachable";
         break;
       case HTTPEvent::Type::HEADERS_COMPLETE:
         processIngressHeadersComplete(callback.getHeaders());
         break;
       case HTTPEvent::Type::BODY: {
         unique_ptr<IOBuf> data = callback.getBody();
         auto len = data->computeChainDataLength();
         CHECK(recvWindow_.free(len));
         processIngressBody(std::move(data), len);
       } break;
       case HTTPEvent::Type::CHUNK_HEADER:
         processIngressChunkHeader(callback.getChunkLength());
         break;
       case HTTPEvent::Type::CHUNK_COMPLETE:
         processIngressChunkComplete();
         break;
       case HTTPEvent::Type::TRAILERS_COMPLETE:
         processIngressTrailers(callback.getTrailers());
         break;
       case HTTPEvent::Type::MESSAGE_COMPLETE:
         processIngressEOM();
         break;
       case HTTPEvent::Type::UPGRADE:
         processIngressUpgrade(callback.getUpgradeProtocol());
         break;
     }
     if (deferredIngress_) {
       deferredIngress_->pop();
     }
   }
   updateReadTimeout();
   inResume_ = false;
 }

void proxygen::HTTPTransaction::sendAbort ( )

virtual

Terminate the transaction. Depending on the underlying protocol, this may cause the connection to close or write egress bytes. This method does not actually write the message out on the wire immediately. All writes happen at the end of the event loop at the earliest.

This function may also cause additional callbacks such as detachTransaction() to the handler either immediately or after it returns.

Definition at line 1047 of file HTTPTransaction.cpp.

References proxygen::CANCEL, proxygen::INTERNAL_ERROR, and isUpstream().

Referenced by proxygen::HTTPSessionBase::handleErrorDirectly(), proxygen::CodecErrorResponseHandler::onError(), ProxyService::ProxyHandler::onError(), onError(), onIngressBody(), onIngressEOM(), onIngressSetSendWindow(), onIngressWindowUpdate(), proxygen::RequestHandlerAdaptor::sendAbort(), proxygen::HTTPHandlerBase::terminate(), and TEST_F().

                                 {
   sendAbort(isUpstream() ? ErrorCode::CANCEL
                          : ErrorCode::INTERNAL_ERROR);
 }

void proxygen::HTTPTransaction::sendAbort ( ErrorCode statusCode )

private

Implementation of sending an abort for this transaction.

Definition at line 1052 of file HTTPTransaction.cpp.

References aborted_, g(), proxygen::HTTPTransactionTransportCallback::headerBytesGenerated(), markEgressComplete(), markIngressComplete(), proxygen::HTTPTransaction::Transport::sendAbort(), folly::size(), transport_, transportCallback_, and wangle::HTTPHeaderSize::uncompressed.

                                                     {
   DestructorGuard g(this);
   markIngressComplete();
   markEgressComplete();
   if (aborted_) {
     // This can happen in cases where the abort is sent before notifying the
     // handler, but its logic also wants to abort
     VLOG(4) << "skipping redundant abort";
     return;
   }
   VLOG(4) << "aborting transaction " << *this;
   aborted_ = true;
   size_t nbytes = transport_.sendAbort(this, statusCode);
   if (transportCallback_) {
     HTTPHeaderSize size;
     size.uncompressed = nbytes;
     transportCallback_->headerBytesGenerated(size);
   }
 }

void proxygen::HTTPTransaction::sendBody ( std::unique_ptr< folly::IOBuf > body )

virtual

Send part or all of the egress message body to the Transport. If flow control is enabled, the chunk boundaries may not be respected. This method does not actually write the message out on the wire immediately. All writes happen at the end of the event loop at the earliest. Note: This method may be called zero or more times per message.

Parameters

body	Message body data; the Transport will take care of applying any necessary protocol framing, such as chunk headers.

Reimplemented in proxygen::MockHTTPTransaction.

Definition at line 784 of file HTTPTransaction.cpp.

References actualResponseLength_, folly::IOBufQueue::append(), folly::IOBuf::computeChainDataLength(), deferredEgressBody_, egressState_, folly::gen::guard(), isEnqueued(), folly::gen::move, proxygen::HTTPTransaction::Transport::notifyEgressBodyBuffered(), notifyTransportPendingEgress(), proxygen::StateMachine< T >::transit(), transport_, and folly::Optional< Value >::value().

Referenced by ProxyService::ProxyHandler::onBody(), proxygen::HTTPDirectResponseHandler::onHeadersComplete(), proxygen::RequestHandlerAdaptor::sendBody(), proxygen::HTTPHandlerBase::sendBody(), proxygen::HTTPHandlerBase::sendChunkedReplyWithBody(), CurlService::CurlClient::sendRequest(), and DownstreamTransactionTest::setupRequestResponseFlow().

                                                              {
   DestructorGuard guard(this);
   CHECK(HTTPTransactionEgressSM::transit(
       egressState_, HTTPTransactionEgressSM::Event::sendBody));
 
   if (body) {
     size_t bodyLen = body->computeChainDataLength();
     actualResponseLength_ = actualResponseLength_.value() + bodyLen;
 
     if (isEnqueued()) {
       transport_.notifyEgressBodyBuffered(bodyLen);
     }
   }
   deferredEgressBody_.append(std::move(body));
   notifyTransportPendingEgress();
 }

void proxygen::HTTPTransaction::sendBodyFlowControlled ( std::unique_ptr< folly::IOBuf > body = nullptr )

private

size_t proxygen::HTTPTransaction::sendBodyNow	(	std::unique_ptr< folly::IOBuf >	body,
		size_t	bodyLen,
		bool	eom
	)

private

Definition at line 955 of file HTTPTransaction.cpp.

References egressLimitBytesPerMs_, egressState_, enableLastByteFlushedTracking_, proxygen::FLOW_CONTROL_ERROR, proxygen::Window::getCapacity(), proxygen::Window::getSize(), id_, proxygen::HTTPException::INGRESS_AND_EGRESS, ingressErrorSeen_, isExpectingWindowUpdate(), isPrioritySampled(), proxygen::kErrorEOF, folly::gen::move, numLimitedBytesEgressed_, onError(), proxygen::Window::reserve(), proxygen::HTTPTransaction::Transport::sendBody(), sendEOMNow(), sendWindow_, proxygen::HTTPException::setCodecStatusCode(), proxygen::Exception::setProxygenError(), string, trailers_, proxygen::StateMachine< T >::transit(), transport_, updateReadTimeout(), updateTransactionBytesSent(), and useFlowControl_.

Referenced by sendDeferredBody().

                                                                   {
   static const std::string noneStr = "None";
   DCHECK(body);
   DCHECK_GT(bodyLen, 0);
   size_t nbytes = 0;
   if (useFlowControl_) {
     CHECK(sendWindow_.reserve(bodyLen));
   }
   VLOG(4) << "Sending " << bodyLen
           << " bytes of body. eom=" << ((sendEom) ? "yes" : "no")
           << " send_window is "
           << (useFlowControl_
                   ? folly::to<std::string>(
                         sendWindow_.getSize(), " / ", sendWindow_.getCapacity())
                   : noneStr)
           << " trailers=" << ((trailers_) ? "yes" : "no") << " " << *this;
   if (sendEom && !trailers_) {
     CHECK(HTTPTransactionEgressSM::transit(
             egressState_, HTTPTransactionEgressSM::Event::eomFlushed));
   } else if (ingressErrorSeen_ && isExpectingWindowUpdate()) {
     // I don't know how we got here but we're in trouble.  We need a window
     // update to continue but we've already seen an ingress error.
     HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS,
                      folly::to<std::string>("window blocked with ingress error,"
                                             " streamID=", id_));
     ex.setProxygenError(kErrorEOF);
     ex.setCodecStatusCode(ErrorCode::FLOW_CONTROL_ERROR);
     onError(ex);
     return 0;
   }
   updateReadTimeout();
   nbytes = transport_.sendBody(this,
                                std::move(body),
                                sendEom && !trailers_,
                                enableLastByteFlushedTracking_);
   if (sendEom && trailers_) {
     sendEOMNow();
   }
   if (isPrioritySampled()) {
     updateTransactionBytesSent(bodyLen);
   }
   if (egressLimitBytesPerMs_ > 0) {
     numLimitedBytesEgressed_ += nbytes;
   }
   return nbytes;
 }

virtual void proxygen::HTTPTransaction::sendChunkHeader ( size_t length )

inlinevirtual

Write any protocol framing required for the subsequent call(s) to sendBody(). This method does not actually write the message out on the wire immediately. All writes happen at the end of the event loop at the earliest.

Parameters

length Length in bytes of the body data to follow.

Definition at line 825 of file HTTPTransaction.h.

References proxygen::StateMachine< T >::transit(), and transport_.

Referenced by proxygen::HTTPHandlerBase::sendChunkedReplyWithBody(), and proxygen::RequestHandlerAdaptor::sendChunkHeader().

                                               {
     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 proxygen::HTTPTransaction::sendChunkTerminator ( )

inlinevirtual

Write any protocol syntax needed to terminate the data. This method does not actually write the message out on the wire immediately. All writes happen at the end of the event loop at the earliest. Frame begun by the last call to sendChunkHeader().

Definition at line 840 of file HTTPTransaction.h.

References proxygen::StateMachine< T >::transit().

Referenced by proxygen::HTTPHandlerBase::sendChunkedReplyWithBody(), and proxygen::RequestHandlerAdaptor::sendChunkTerminator().

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

size_t proxygen::HTTPTransaction::sendDeferredBody ( uint32_t maxEgress )

private

Definition at line 814 of file HTTPTransaction.cpp.

References proxygen::HTTPTransactionTransportCallback::bodyBytesGenerated(), folly::IOBufQueue::chainLength(), chunkHeaders_, deferredEgressBody_, dequeue(), proxygen::Window::getSize(), hasPendingEOM(), proxygen::HTTPTransaction::Chunk::headerSent, int32_t, isEgressEOMQueued(), proxygen::HTTPTransaction::Chunk::length, maybeDelayForRateLimit(), folly::gen::move, notifyTransportPendingEgress(), sendBodyNow(), proxygen::HTTPTransaction::Transport::sendChunkHeader(), proxygen::HTTPTransaction::Transport::sendChunkTerminator(), sendEOMNow(), sendWindow_, folly::IOBufQueue::split(), transport_, transportCallback_, uint32_t, and useFlowControl_.

Referenced by onWriteReady().

                                                                  {
   const int32_t windowAvailable = sendWindow_.getSize();
   const uint32_t sendWindow = useFlowControl_ ? std::min<uint32_t>(
     maxEgress, windowAvailable > 0 ? windowAvailable : 0) : maxEgress;
 
   // We shouldn't be called if we have no pending body/EOM, egress is paused, or
   // the send window is closed
   CHECK((deferredEgressBody_.chainLength() > 0 ||
          isEgressEOMQueued()) &&
         sendWindow > 0);
 
   const size_t bytesLeft = deferredEgressBody_.chainLength();
 
   size_t canSend = std::min<size_t>(sendWindow, bytesLeft);
 
   if (maybeDelayForRateLimit()) {
     // Timeout will call notifyTransportPendingEgress again
     return 0;
   }
 
   size_t curLen = 0;
   size_t nbytes = 0;
   bool willSendEOM = false;
 
   if (chunkHeaders_.empty()) {
     curLen = canSend;
     std::unique_ptr<IOBuf> body = deferredEgressBody_.split(curLen);
     willSendEOM = hasPendingEOM();
     DCHECK(curLen > 0 || willSendEOM);
     if (curLen > 0) {
       if (willSendEOM) {
         // we have to dequeue BEFORE sending the EOM =(
         dequeue();
       }
       nbytes = sendBodyNow(std::move(body), curLen, willSendEOM);
       willSendEOM = false;
     } // else we got called with only a pending EOM, handled below
   } else {
     // This body is expliticly chunked
     while (!chunkHeaders_.empty() && canSend > 0) {
       Chunk& chunk = chunkHeaders_.front();
       if (!chunk.headerSent) {
         nbytes += transport_.sendChunkHeader(this, chunk.length);
         chunk.headerSent = true;
       }
       curLen = std::min<size_t>(chunk.length, canSend);
       std::unique_ptr<folly::IOBuf> cur = deferredEgressBody_.split(curLen);
       VLOG(4) << "sending " << curLen << " fin=false";
       nbytes += sendBodyNow(std::move(cur), curLen, false);
       canSend -= curLen;
       chunk.length -= curLen;
       if (chunk.length == 0) {
         nbytes += transport_.sendChunkTerminator(this);
         chunkHeaders_.pop_front();
       } else {
         DCHECK_EQ(canSend, 0);
       }
     }
     willSendEOM = hasPendingEOM();
   }
   // Send any queued eom
   if (willSendEOM) {
     nbytes += sendEOMNow();
   }
 
   // Update the handler's pause state
   notifyTransportPendingEgress();
 
   if (transportCallback_) {
     transportCallback_->bodyBytesGenerated(nbytes);
   }
   return nbytes;
 }

void proxygen::HTTPTransaction::sendEOM ( )

virtual

Finalize the egress message; depending on the protocol used by the Transport, this may involve sending an explicit "end of message" indicator. This method does not actually write the message out on the wire immediately. All writes happen at the end of the event loop at the earliest.

If the ingress message also is complete, the transaction may detach itself from the Handler and Transport and delete itself as part of this method.

Note: Either this method or sendAbort() should be called once per message.

Definition at line 1003 of file HTTPTransaction.cpp.

References aborted_, actualResponseLength_, proxygen::HTTPTransactionTransportCallback::bodyBytesGenerated(), folly::IOBufQueue::chainLength(), chunkHeaders_, deferredEgressBody_, egressPaused_, egressState_, proxygen::ERROR, expectedResponseLength_, g(), ingressPaused_, ingressState_, isEnqueued(), proxygen::HTTPTransaction::Transport::notifyPendingEgress(), notifyTransportPendingEgress(), sendEOMNow(), proxygen::StateMachine< T >::transit(), transport_, and transportCallback_.

Referenced by proxygen::HTTPDirectResponseHandler::onEOM(), ProxyService::ProxyHandler::onEOM(), proxygen::HTTPHandlerBase::sendChunkedReplyWithBody(), proxygen::RequestHandlerAdaptor::sendEOM(), proxygen::HTTPHandlerBase::sendEOM(), proxygen::HTTPHandlerBase::sendReplyCode(), proxygen::HTTPHandlerBase::sendReplyWithBody(), proxygen::HTTPHandlerBase::sendRequest(), CurlService::CurlClient::sendRequest(), DownstreamTransactionTest::setupRequestResponseFlow(), and TEST_F().

                               {
   DestructorGuard g(this);
   CHECK(HTTPTransactionEgressSM::transit(
       egressState_, HTTPTransactionEgressSM::Event::sendEOM))
       << ", " << *this;
   if (expectedResponseLength_ && actualResponseLength_ &&
       (*expectedResponseLength_ != *actualResponseLength_)) {
     auto errorMsg =
         folly::to<std::string>("Content-Length/body mismatch: expected= ",
                                *expectedResponseLength_,
                                ", actual= ",
                                *actualResponseLength_);
     LOG(ERROR) << errorMsg << " " << *this;
   }
 
   if (deferredEgressBody_.chainLength() == 0 && chunkHeaders_.empty()) {
     // there is nothing left to send, egress the EOM directly.  For SPDY
     // this will jump the txn queue
     if (!isEnqueued()) {
       size_t nbytes = sendEOMNow();
       transport_.notifyPendingEgress();
       if (transportCallback_) {
         transportCallback_->bodyBytesGenerated(nbytes);
       }
     } else {
       // If the txn is enqueued, sendDeferredBody()
       // should take care of sending the EOM.
       // This can happen for some uses of the egress queue
       VLOG(4) << "Queued egress EOM with no body"
               << "[egressState=" << egressState_ << ", "
               << "ingressState=" << ingressState_ << ", "
               << "egressPaused=" << egressPaused_ << ", "
               << "ingressPaused=" << ingressPaused_ << ", "
               << "aborted=" << aborted_ << ", "
               << "enqueued=" << isEnqueued() << ", "
               << "chainLength=" << deferredEgressBody_.chainLength() << "]"
               << " on " << *this;
     }
   } else {
     VLOG(4) << "Queued egress EOM on " << *this;
     notifyTransportPendingEgress();
   }
 }

size_t proxygen::HTTPTransaction::sendEOMNow ( )

private

Definition at line 944 of file HTTPTransaction.cpp.

References egressState_, proxygen::HTTPTransaction::Transport::sendEOM(), trailers_, proxygen::StateMachine< T >::transit(), and transport_.

Referenced by sendBodyNow(), sendDeferredBody(), and sendEOM().

                                    {
   VLOG(4) << "egress EOM on " << *this;
   // TODO: with ByteEvent refactor, we will have to delay changing this
   // state until later
   CHECK(HTTPTransactionEgressSM::transit(
           egressState_, HTTPTransactionEgressSM::Event::eomFlushed));
   size_t nbytes = transport_.sendEOM(this, trailers_.get());
   trailers_.reset();
   return nbytes;
 }

void proxygen::HTTPTransaction::sendHeaders ( const HTTPMessage & headers )

virtual

Send the egress message headers to the Transport. This method does not actually write the message out on the wire immediately. All writes happen at the end of the event loop at the earliest. Note: This method should be called once per message unless the first headers sent indicate a 1xx status.

sendHeaders will not set EOM flag in header frame, whereas sendHeadersWithEOM will. sendHeadersWithOptionalEOM backs both of them.

Parameters

headers Message headers

Definition at line 780 of file HTTPTransaction.cpp.

References sendHeadersWithOptionalEOM().

Referenced by proxygen::HTTPDirectResponseHandler::onHeadersComplete(), proxygen::HTTPHandlerBase::sendChunkedReplyWithBody(), proxygen::HTTPHandlerBase::sendHeaders(), proxygen::RequestHandlerAdaptor::sendHeaders(), proxygen::MockHTTPPushHandler::sendPushHeaders(), proxygen::HTTPHandlerBase::sendRequest(), CurlService::CurlClient::sendRequest(), and DownstreamTransactionTest::setupRequestResponseFlow().

                                                            {
   sendHeadersWithOptionalEOM(header, false);
 }

void proxygen::HTTPTransaction::sendHeadersWithEOM ( const HTTPMessage & headers )

virtual

Definition at line 776 of file HTTPTransaction.cpp.

References sendHeadersWithOptionalEOM().

                                                                   {
   sendHeadersWithOptionalEOM(header, true);
 }

void proxygen::HTTPTransaction::sendHeadersWithOptionalEOM	(	const HTTPMessage &	headers,
		bool	eom
	)

virtual

Definition at line 729 of file HTTPTransaction.cpp.

References proxygen::HTTPTransactionTransportCallback::bodyBytesGenerated(), egressState_, proxygen::ERROR, expectedResponseLength_, flushWindowUpdate(), proxygen::HTTPTransaction::Transport::getCodec(), proxygen::HTTPMessage::getHeaders(), proxygen::HTTPCodec::getHPACKTableInfo(), proxygen::HTTPMessage::getMethod(), proxygen::HTTPCodec::getProtocol(), proxygen::HTTPHeaders::getSingleOrEmpty(), proxygen::HTTPMessage::getStatusCode(), proxygen::HEAD, proxygen::HTTPTransactionTransportCallback::headerBytesGenerated(), headRequest_, proxygen::HTTP_2, proxygen::HTTP_HEADER_CONTENT_LENGTH, isEgressComplete(), isPushed(), proxygen::HTTPMessage::isRequest(), proxygen::HTTPMessage::isResponse(), lastResponseStatus_, proxygen::HTTPTransaction::Transport::sendHeaders(), folly::size(), proxygen::StateMachine< T >::transit(), transport_, transportCallback_, and updateEgressHPACKTableInfo().

Referenced by sendHeaders(), and sendHeadersWithEOM().

               {
   CHECK(HTTPTransactionEgressSM::transit(
           egressState_, HTTPTransactionEgressSM::Event::sendHeaders));
   DCHECK(!isEgressComplete());
   if (!headers.isRequest() && !isPushed()) {
     lastResponseStatus_ = headers.getStatusCode();
   }
   if (headers.isRequest()) {
     headRequest_ = (headers.getMethod() == HTTPMethod::HEAD);
   }
 
   if (headers.isResponse() && !headRequest_) {
     const auto& contentLen =
       headers.getHeaders().getSingleOrEmpty(HTTP_HEADER_CONTENT_LENGTH);
     if (!contentLen.empty()) {
       try {
         expectedResponseLength_ = folly::to<uint64_t>(contentLen);
       } catch (const folly::ConversionError& ex) {
         LOG(ERROR) << "Invalid content-length: " << contentLen <<
           ", ex=" << ex.what() << *this;
       }
     }
   }
   HTTPHeaderSize size;
   transport_.sendHeaders(this, headers, &size, eom);
   if (transportCallback_) {
     transportCallback_->headerBytesGenerated(size);
   }
   if (transport_.getCodec().getProtocol() == CodecProtocol::HTTP_2) {
     updateEgressHPACKTableInfo(transport_.getCodec().getHPACKTableInfo());
   }
   if (eom) {
     CHECK(HTTPTransactionEgressSM::transit(
           egressState_, HTTPTransactionEgressSM::Event::sendEOM));
     // trailers are supported in this case:
     // trailers are for chunked encoding-transfer of a body
     if (transportCallback_) {
       transportCallback_->bodyBytesGenerated(0);
     }
     CHECK(HTTPTransactionEgressSM::transit(
           egressState_, HTTPTransactionEgressSM::Event::eomFlushed));
   }
   flushWindowUpdate();
 }

virtual void proxygen::HTTPTransaction::sendTrailers ( const HTTPHeaders & trailers )

inlinevirtual

Send message trailers to the Transport. This method does not actually write the message out on the wire immediately. All writes happen at the end of the event loop at the earliest. Note: This method may be called at most once per message.

Parameters

trailers Message trailers.

Definition at line 853 of file HTTPTransaction.h.

References proxygen::StateMachine< T >::transit().

Referenced by proxygen::ResponseBuilder::send(), proxygen::HTTPHandlerBase::sendChunkedReplyWithBody(), and proxygen::HTTPHandlerBase::sendReplyWithBody().

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

void proxygen::HTTPTransaction::setEgressRateLimit ( uint64_t bitsPerSecond )

Specify a rate limit for egressing bytes. The transaction will buffer extra bytes if doing so would cause it to go over the specified rate limit. Setting to a value of 0 will cause no rate-limiting to occur.

Definition at line 1172 of file HTTPTransaction.cpp.

References egressLimitBytesPerMs_, proxygen::getCurrentTime(), numLimitedBytesEgressed_, and startRateLimit_.

                                                                {
   egressLimitBytesPerMs_ = bitsPerSecond / 8000;
   if (bitsPerSecond > 0 && egressLimitBytesPerMs_ == 0) {
     VLOG(4) << "ratelim: Limit too low (" << bitsPerSecond << "), ignoring";
   }
   startRateLimit_ = getCurrentTime();
   numLimitedBytesEgressed_ = 0;
 }

virtual void proxygen::HTTPTransaction::setHandler ( Handler * handler )

inlinevirtual

Definition at line 477 of file HTTPTransaction.h.

References handler().

Referenced by proxygen::HTTPSessionBase::handleErrorDirectly(), proxygen::HTTPSession::newExTransaction(), proxygen::HTTPSession::newPushedTransaction(), proxygen::MockHTTPTransaction::setHandlerUnmocked(), proxygen::HTTPDownstreamSession::setupOnHeadersComplete(), DownstreamTransactionTest::setupRequestResponseFlow(), TEST(), and TEST_F().

                                             {
     handler_ = handler;
     if (handler_) {
       handler_->setTransaction(this);
     }
   }

void proxygen::HTTPTransaction::setIdleTimeout ( std::chrono::milliseconds transactionTimeout )

Sets a transaction timeout value. If such a timeout was set, this timeout will be used instead of the default timeout interval configured in transactionIdleTimeouts_.

Definition at line 1295 of file HTTPTransaction.cpp.

References count, refreshTimeout(), and transactionTimeout_.

                                               {
   transactionTimeout_ = transactionTimeout;
   VLOG(4) << "HTTPTransaction: transaction timeout is set to  "
           << std::chrono::duration_cast<std::chrono::milliseconds>(
                  transactionTimeout)
                  .count();
   refreshTimeout();
 }

void proxygen::HTTPTransaction::setLastByteFlushedTrackingEnabled ( bool enabled )

inline

Definition at line 1224 of file HTTPTransaction.h.

References int32_t, statusCode, and uint32_t.

Referenced by proxygen::HTTPHandlerBase::sendBodyWithLastByteTracking().

                                                        {
     enableLastByteFlushedTracking_ = enabled;
   }

void proxygen::HTTPTransaction::setPrioritySampled ( bool sampled )

Definition at line 1495 of file HTTPTransaction.cpp.

References prioritySample_.

Referenced by proxygen::HTTPSession::createTransaction().

                                                      {
   if (sampled) {
     prioritySample_ = std::make_unique<PrioritySample>(this);
   } else {
     prioritySample_.reset();
   }
 }

void proxygen::HTTPTransaction::setReceiveWindow ( uint32_t capacity )

virtual

Change the size of the receive window and propagate the change to the remote end using a window update.

TODO: when HTTPSession sends a SETTINGS frame indicating a different initial window, it should call this function on all its transactions.

Definition at line 1315 of file HTTPTransaction.cpp.

References flushWindowUpdate(), proxygen::Window::getCapacity(), int32_t, recvToAck_, recvWindow_, proxygen::Window::setCapacity(), and useFlowControl_.

Referenced by proxygen::HTTPSession::createTransaction(), and reset().

                                                         {
   // Depending on whether delta is positive or negative it will cause the
   // window to either increase or decrease.
   if (!useFlowControl_) {
     return;
   }
   int32_t delta = capacity - recvWindow_.getCapacity();
   if (delta < 0) {
     // For now, we're disallowing shrinking the window, since it can lead
     // to FLOW_CONTROL_ERRORs if there is data in flight.
     VLOG(4) << "Refusing to shrink the recv window";
     return;
   }
   if (!recvWindow_.setCapacity(capacity)) {
     return;
   }
   recvToAck_ += delta;
   flushWindowUpdate();
 }

void proxygen::HTTPTransaction::setTransportCallback ( TransportCallback * cb )

inline

Invoked by the handlers that are interested in tracking performance stats.

Definition at line 702 of file HTTPTransaction.h.

                                                    {
     transportCallback_ = cb;
   }

bool proxygen::HTTPTransaction::supportsPushTransactions ( ) const

inline

Returns: true iff this transaction can be used to push resources to the remote side.

Definition at line 953 of file HTTPTransaction.h.

References proxygen::DOWNSTREAM, and transport_.

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

bool proxygen::HTTPTransaction::testAndClearActive ( )

inline

Definition at line 1116 of file HTTPTransaction.h.

Referenced by proxygen::HTTPSession::decrementTransactionCount().

                             {
     bool ret = inActiveSet_;
     inActiveSet_ = false;
     return ret;
   }

bool proxygen::HTTPTransaction::testAndSetFirstByteSent ( )

inline

Tests if the first byte has already been sent, and if it hasn't yet then it marks it as sent.

Definition at line 1110 of file HTTPTransaction.h.

Referenced by proxygen::HTTPSessionBase::handleLastByteEvents().

                                  {
     bool ret = firstByteSent_;
     firstByteSent_ = true;
     return ret;
   }

bool proxygen::HTTPTransaction::testAndSetFirstHeaderByteSent ( )

inline

Tests if the very first byte of Header has already been set. If it hasn't yet, it marks it as sent.

Definition at line 1126 of file HTTPTransaction.h.

                                        {
     bool ret = firstHeaderByteSent_;
     firstHeaderByteSent_ = true;
     return ret;
   }

void proxygen::HTTPTransaction::timeoutExpired ( )

inlineoverridevirtualnoexcept

Timeout callback for this transaction. The timer is active until the ingress message is complete or terminated by error.

Implements folly::HHWheelTimer::Callback.

Definition at line 1152 of file HTTPTransaction.h.

References int8_t, and transport_.

Referenced by TEST_F().

                                           {
     transport_.transactionTimeout(this);
   }

void proxygen::HTTPTransaction::updateAndSendPriority ( int8_t newPriority )

Change the priority of this transaction, may generate a PRIORITY frame

Definition at line 1359 of file HTTPTransaction.cpp.

References egressQueue_, proxygen::HTTPTransaction::Transport::getCodec(), proxygen::HTTPCodec::mapPriorityToDependency(), proxygen::HTTPMessage::normalizePriority(), priority_, queueHandle_, proxygen::HTTPTransaction::Transport::sendPriority(), proxygen::http2::PriorityUpdate::streamDependency, transport_, and proxygen::HTTP2PriorityQueueBase::updatePriority().

                                                               {
   newPriority = HTTPMessage::normalizePriority(newPriority);
   CHECK_GE(newPriority, 0);
   priority_.streamDependency =
     transport_.getCodec().mapPriorityToDependency(newPriority);
   queueHandle_ = egressQueue_.updatePriority(queueHandle_, priority_);
   transport_.sendPriority(this, priority_);
 }

void proxygen::HTTPTransaction::updateAndSendPriority ( const http2::PriorityUpdate & pri )

Definition at line 1368 of file HTTPTransaction.cpp.

References onPriorityUpdate(), priority_, proxygen::HTTPTransaction::Transport::sendPriority(), and transport_.

                                           {
   onPriorityUpdate(newPriority);
   transport_.sendPriority(this, priority_);
 }

void proxygen::HTTPTransaction::updateContentionsCount ( uint64_t contentions )

Definition at line 1503 of file HTTPTransaction.cpp.

References proxygen::HTTP2PriorityQueueBase::BaseNode::calculateDepth(), prioritySample_, and queueHandle_.

Referenced by proxygen::HTTPSession::runLoopCallback().

                                                                  {
   CHECK(prioritySample_);
   prioritySample_->updateContentionsCount(contentions,
                                           queueHandle_->calculateDepth(false));
 }

void proxygen::HTTPTransaction::updateEgressHPACKTableInfo ( HPACKTableInfo tableInfo )

private

Update the HPACKTableInfo (tableInfo_) struct

Definition at line 1240 of file HTTPTransaction.cpp.

References proxygen::HPACKTableInfo::egressBytesStored_, proxygen::HPACKTableInfo::egressHeadersStored_, proxygen::HPACKTableInfo::egressHeaderTableSize_, and tableInfo_.

Referenced by sendHeadersWithOptionalEOM().

                                                                          {
   tableInfo_.egressHeaderTableSize_ =
                             tableInfo.egressHeaderTableSize_;
   tableInfo_.egressBytesStored_ =
                             tableInfo.egressBytesStored_;
   tableInfo_.egressHeadersStored_ =
                             tableInfo.egressHeadersStored_;
 }

void proxygen::HTTPTransaction::updateHandlerPauseState ( )

private

Invokes the handler's onEgressPaused/Resumed if the handler's pause state needs updating

Definition at line 1205 of file HTTPTransaction.cpp.

References folly::IOBufQueue::chainLength(), deferredEgressBody_, egressPaused_, egressRateLimited_, flowControlPaused_, proxygen::Window::getSize(), handler_, handlerEgressPaused_, int64_t, proxygen::HTTPTransactionHandler::onEgressPaused(), proxygen::HTTPTransactionHandler::onEgressResumed(), proxygen::HTTPSessionStats::recordTransactionStalled(), sendWindow_, stats_, and useFlowControl_.

Referenced by notifyTransportPendingEgress(), pauseEgress(), and resumeEgress().

                                               {
   int64_t availWindow =
     sendWindow_.getSize() - deferredEgressBody_.chainLength();
   // do not count transaction stalled if no more bytes to send,
   // i.e. when availWindow == 0
   if (useFlowControl_ && availWindow < 0 && !flowControlPaused_) {
     VLOG(4) << "transaction stalled by flow control" << *this;
     if (stats_) {
       stats_->recordTransactionStalled();
     }
   }
   flowControlPaused_ = useFlowControl_ && availWindow <= 0;
   bool handlerShouldBePaused = egressPaused_ || flowControlPaused_ ||
     egressRateLimited_;
 
   if (handler_ && handlerShouldBePaused != handlerEgressPaused_) {
     if (handlerShouldBePaused) {
       handlerEgressPaused_ = true;
       handler_->onEgressPaused();
     } else {
       handlerEgressPaused_ = false;
       handler_->onEgressResumed();
     }
   }
 }

void proxygen::HTTPTransaction::updateIngressHPACKTableInfo ( HPACKTableInfo tableInfo )

private

Definition at line 1231 of file HTTPTransaction.cpp.

References proxygen::HPACKTableInfo::ingressBytesStored_, proxygen::HPACKTableInfo::ingressHeadersStored_, proxygen::HPACKTableInfo::ingressHeaderTableSize_, and tableInfo_.

Referenced by onIngressHeadersComplete().

                                                                           {
     tableInfo_.ingressHeaderTableSize_ =
                             tableInfo.ingressHeaderTableSize_;
     tableInfo_.ingressBytesStored_ =
                             tableInfo.ingressBytesStored_;
     tableInfo_.ingressHeadersStored_ =
                             tableInfo.ingressHeadersStored_;
 }

void proxygen::HTTPTransaction::updateReadTimeout ( )

private

Definition at line 488 of file HTTPTransaction.cpp.

References folly::HHWheelTimer::Callback::cancelTimeout(), isExpectingIngress(), and refreshTimeout().

Referenced by onIngressEOM(), onIngressSetSendWindow(), onIngressWindowUpdate(), processIngressEOM(), resumeIngress(), and sendBodyNow().

                                         {
   if (isExpectingIngress()) {
     refreshTimeout();
   } else {
     cancelTimeout();
   }
 }

void proxygen::HTTPTransaction::updateRelativeWeight ( double ratio )

Definition at line 1509 of file HTTPTransaction.cpp.

References prioritySample_.

Referenced by onWriteReady().

                                                        {
   CHECK(prioritySample_);
   prioritySample_->updateRatio(ratio);
 }

void proxygen::HTTPTransaction::updateSessionBytesSheduled ( uint64_t bytes )

Definition at line 1514 of file HTTPTransaction.cpp.

References egressPaused_, egressRateLimited_, firstHeaderByteSent_, flowControlPaused_, and prioritySample_.

Referenced by proxygen::HTTPSession::runLoopCallback().

                                                                {
   CHECK(prioritySample_);
   // Do not accumulate session bytes utill header is sent.
   // Otherwise, the session bytes could be accumulated for a transaction
   // that is not allowed to egress yet.
   // Do not accumulate session bytes if transaction is paused.
   // On the other hand, if the transaction is part of the egress,
   // always accumulate the session bytes.
   if ((bytes && firstHeaderByteSent_ && !egressPaused_ &&
     !egressRateLimited_ && !flowControlPaused_)
     || prioritySample_->isTransactionBytesScheduled()) {
     prioritySample_->updateSessionBytesSheduled(bytes);
   }
 }

void proxygen::HTTPTransaction::updateTransactionBytesSent ( uint64_t bytes )

Definition at line 1529 of file HTTPTransaction.cpp.

References prioritySample_.

Referenced by sendBodyNow().

                                                                {
   CHECK(prioritySample_);
   if (bytes) {
     prioritySample_->updateTransactionBytesSent(bytes);
   }
 }

bool proxygen::HTTPTransaction::validateIngressStateTransition ( HTTPTransactionIngressSM::Event event )

private

Validates the ingress state transition. Returns false and sends an abort with PROTOCOL_ERROR if the transition fails. Otherwise it returns true.

Definition at line 517 of file HTTPTransaction.cpp.

References g(), id_, proxygen::HTTPException::INGRESS_AND_EGRESS, ingressState_, proxygen::INTERNAL_ERROR, proxygen::kErrorIngressStateTransition, onError(), proxygen::Exception::setProxygenError(), and proxygen::StateMachine< T >::transit().

Referenced by onIngressBody(), onIngressChunkComplete(), onIngressChunkHeader(), onIngressEOM(), onIngressHeadersComplete(), onIngressTrailers(), onIngressUpgrade(), and processIngressEOM().

                                          {
   DestructorGuard g(this);
 
   if (!HTTPTransactionIngressSM::transit(ingressState_, event)) {
     std::stringstream ss;
     ss << "Invalid ingress state transition, state=" << ingressState_ <<
       ", event=" << event << ", streamID=" << id_;
     HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS, ss.str());
     ex.setProxygenError(kErrorIngressStateTransition);
     ex.setCodecStatusCode(ErrorCode::INTERNAL_ERROR);
     // This will invoke sendAbort() and also inform the handler of the
     // error and detach the handler.
     onError(ex);
     return false;
   }
   return true;
 }

Member Data Documentation

bool proxygen::HTTPTransaction::aborted_

private

Definition at line 1473 of file HTTPTransaction.h.

Referenced by onError(), processIngressBody(), processIngressChunkComplete(), processIngressChunkHeader(), processIngressEOM(), processIngressHeadersComplete(), processIngressTrailers(), processIngressUpgrade(), sendAbort(), and sendEOM().

folly::Optional<uint64_t> proxygen::HTTPTransaction::actualResponseLength_ {0}

private

Definition at line 1465 of file HTTPTransaction.h.

Referenced by sendBody(), and sendEOM().

folly::Optional<HTTPCodec::StreamID> proxygen::HTTPTransaction::assocStreamId_

private

ID of request transaction (for pushed txns only)

Definition at line 1416 of file HTTPTransaction.h.

Referenced by HTTPTransaction(), and onPushedTransaction().

std::list<Chunk> proxygen::HTTPTransaction::chunkHeaders_

private

Definition at line 1396 of file HTTPTransaction.h.

Referenced by sendDeferredBody(), and sendEOM().

double proxygen::HTTPTransaction::cumulativeRatio_ {0}

private

Definition at line 1451 of file HTTPTransaction.h.

Referenced by onWriteReady().

uint64_t proxygen::HTTPTransaction::currentDepth_ {0}

private

Definition at line 1450 of file HTTPTransaction.h.

Referenced by HTTPTransaction(), and onPriorityUpdate().

folly::IOBufQueue proxygen::HTTPTransaction::deferredEgressBody_ {folly::IOBufQueue::cacheChainLength()}

private

Queue to hold any body bytes to be sent out while egress to the remote is supposed to be paused.

Definition at line 1356 of file HTTPTransaction.h.

Referenced by markEgressComplete(), notifyTransportPendingEgress(), sendBody(), sendDeferredBody(), sendEOM(), and updateHandlerPauseState().

std::unique_ptr<std::queue<HTTPEvent> > proxygen::HTTPTransaction::deferredIngress_

private

Queue to hold any events that we receive from the Transaction while the ingress is supposed to be paused.

Definition at line 1348 of file HTTPTransaction.h.

Referenced by checkCreateDeferredIngress(), markIngressComplete(), mustQueueIngress(), onIngressBody(), onIngressChunkComplete(), onIngressChunkHeader(), onIngressEOM(), onIngressHeadersComplete(), onIngressTrailers(), onIngressUpgrade(), and resumeIngress().

bool proxygen::HTTPTransaction::deleting_

private

Definition at line 1474 of file HTTPTransaction.h.

Referenced by onDelayedDestroy().

const TransportDirection proxygen::HTTPTransaction::direction_

private

Definition at line 1358 of file HTTPTransaction.h.

Referenced by flushWindowUpdate().

uint64_t proxygen::HTTPTransaction::egressBufferLimit_

staticprivate

Definition at line 1484 of file HTTPTransaction.h.

uint64_t proxygen::HTTPTransaction::egressCalls_ {0}

private

Definition at line 1452 of file HTTPTransaction.h.

Referenced by onWriteReady().

uint64_t proxygen::HTTPTransaction::egressLimitBytesPerMs_ {0}

private

Definition at line 1486 of file HTTPTransaction.h.

Referenced by maybeDelayForRateLimit(), sendBodyNow(), and setEgressRateLimit().

bool proxygen::HTTPTransaction::egressPaused_

private

Definition at line 1468 of file HTTPTransaction.h.

Referenced by pauseEgress(), resumeEgress(), sendEOM(), updateHandlerPauseState(), and updateSessionBytesSheduled().

HTTP2PriorityQueueBase& proxygen::HTTPTransaction::egressQueue_

private

Reference to our priority queue

Definition at line 1401 of file HTTPTransaction.h.

Referenced by HTTPTransaction(), notifyTransportPendingEgress(), onPriorityUpdate(), updateAndSendPriority(), and ~HTTPTransaction().

bool proxygen::HTTPTransaction::egressRateLimited_

private

Definition at line 1471 of file HTTPTransaction.h.

Referenced by maybeDelayForRateLimit(), notifyTransportPendingEgress(), rateLimitTimeoutExpired(), updateHandlerPauseState(), and updateSessionBytesSheduled().

HTTPTransactionEgressSM::State proxygen::HTTPTransaction::egressState_

private

Initial value:

{

HTTPTransactionEgressSM::getNewInstance()}

Definition at line 1363 of file HTTPTransaction.h.

Referenced by flushWindowUpdate(), HTTPTransaction(), markEgressComplete(), sendBody(), sendBodyNow(), sendEOM(), sendEOMNow(), and sendHeadersWithOptionalEOM().

bool proxygen::HTTPTransaction::enableLastByteFlushedTracking_

private

Definition at line 1482 of file HTTPTransaction.h.

Referenced by sendBodyNow().

folly::Optional<HTTPCodec::ExAttributes> proxygen::HTTPTransaction::exAttributes_

private

Attributes of http2 Ex_HEADERS

Definition at line 1421 of file HTTPTransaction.h.

Referenced by HTTPTransaction().

folly::Optional<uint64_t> proxygen::HTTPTransaction::expectedContentLengthRemaining_

private

Definition at line 1463 of file HTTPTransaction.h.

Referenced by onIngressBody(), onIngressEOM(), and onIngressHeadersComplete().

folly::Optional<uint64_t> proxygen::HTTPTransaction::expectedResponseLength_

private

Definition at line 1464 of file HTTPTransaction.h.

Referenced by sendEOM(), and sendHeadersWithOptionalEOM().

std::set<HTTPCodec::StreamID> proxygen::HTTPTransaction::exTransactions_

private

Set of all exTransaction IDs associated with this transaction.

Definition at line 1431 of file HTTPTransaction.h.

Referenced by onExTransaction().

bool proxygen::HTTPTransaction::firstByteSent_

private

Definition at line 1475 of file HTTPTransaction.h.

bool proxygen::HTTPTransaction::firstHeaderByteSent_

private

Definition at line 1476 of file HTTPTransaction.h.

Referenced by updateSessionBytesSheduled().

bool proxygen::HTTPTransaction::flowControlPaused_

private

Definition at line 1469 of file HTTPTransaction.h.

Referenced by updateHandlerPauseState(), and updateSessionBytesSheduled().

Handler* proxygen::HTTPTransaction::handler_ {nullptr}

private

Definition at line 1361 of file HTTPTransaction.h.

Referenced by onDelayedDestroy(), onEgressTimeout(), onError(), onExTransaction(), onGoaway(), onIngressBody(), onIngressEOM(), onIngressTimeout(), onPushedTransaction(), processIngressBody(), processIngressChunkComplete(), processIngressChunkHeader(), processIngressEOM(), processIngressHeadersComplete(), processIngressTrailers(), processIngressUpgrade(), and updateHandlerPauseState().

bool proxygen::HTTPTransaction::handlerEgressPaused_

private

Definition at line 1470 of file HTTPTransaction.h.

Referenced by updateHandlerPauseState().

bool proxygen::HTTPTransaction::headRequest_

private

Definition at line 1481 of file HTTPTransaction.h.

Referenced by onIngressHeadersComplete(), and sendHeadersWithOptionalEOM().

HTTPCodec::StreamID proxygen::HTTPTransaction::id_

private

Definition at line 1359 of file HTTPTransaction.h.

Referenced by describe(), HTTPTransaction(), onEgressTimeout(), onExTransaction(), onIngressBody(), onIngressChunkComplete(), onIngressChunkHeader(), onIngressEOM(), onIngressHeadersComplete(), onIngressTimeout(), onIngressTrailers(), onIngressUpgrade(), onPushedTransaction(), sendBodyNow(), and validateIngressStateTransition().

bool proxygen::HTTPTransaction::inActiveSet_

private

Definition at line 1478 of file HTTPTransaction.h.

bool proxygen::HTTPTransaction::ingressErrorSeen_

private

Definition at line 1479 of file HTTPTransaction.h.

Referenced by onError(), and sendBodyNow().

bool proxygen::HTTPTransaction::ingressPaused_

private

Definition at line 1467 of file HTTPTransaction.h.

Referenced by isExpectingIngress(), mustQueueIngress(), pauseIngress(), resumeIngress(), and sendEOM().

HTTPTransactionIngressSM::State proxygen::HTTPTransaction::ingressState_

private

Initial value:

{

HTTPTransactionIngressSM::getNewInstance()}

Definition at line 1365 of file HTTPTransaction.h.

Referenced by flushWindowUpdate(), HTTPTransaction(), markIngressComplete(), sendEOM(), and validateIngressStateTransition().

bool proxygen::HTTPTransaction::inResume_

private

Definition at line 1477 of file HTTPTransaction.h.

Referenced by resumeIngress().

uint64_t proxygen::HTTPTransaction::insertDepth_ {0}

private

Information about this transaction's priority.

insertDepth_ is the depth of this node in the tree when the txn was created currentDepth_ is the depth of this node in the tree after the last onPriorityUpdate. It may not reflect its real position in realtime, since after the last onPriorityUpdate, it may get reparented as parent transactions complete. cumulativeRatio_ / egressCalls_ is the average relative weight of this txn during egress

Definition at line 1449 of file HTTPTransaction.h.

Referenced by HTTPTransaction().

uint16_t proxygen::HTTPTransaction::lastResponseStatus_ {0}

private

If this transaction represents a request (ie, it is backed by an HTTPUpstreamSession) , this field indicates the last response status received from the server. If this transaction represents a response, this field indicates the last status we've sent. For instances, this could take on multiple 1xx values, and then take on 200.

Definition at line 1461 of file HTTPTransaction.h.

Referenced by onIngressHeadersComplete(), and sendHeadersWithOptionalEOM().

uint32_t proxygen::HTTPTransaction::maxDeferredIngress_ {0}

private

Definition at line 1350 of file HTTPTransaction.h.

Referenced by resumeIngress().

uint64_t proxygen::HTTPTransaction::numLimitedBytesEgressed_ {0}

private

Definition at line 1488 of file HTTPTransaction.h.

Referenced by maybeDelayForRateLimit(), sendBodyNow(), and setEgressRateLimit().

uint8_t proxygen::HTTPTransaction::pendingByteEvents_ {0}

private