proxygen: proxygen::HTTPUpstreamSession Class Reference

#include <HTTPUpstreamSession.h>

Inheritance diagram for proxygen::HTTPUpstreamSession:

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

Public Types inherited from proxygen::HTTPSession
using	UniquePtr = std::unique_ptr< HTTPSession, Destructor >

Public Types inherited from proxygen::HTTPSessionBase
enum	SessionType { SessionType::HTTP, SessionType::HQ }

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

Public Member Functions
	HTTPUpstreamSession (const WheelTimerInstance &timeout, folly::AsyncTransportWrapper::UniquePtr &&sock, const folly::SocketAddress &localAddr, const folly::SocketAddress &peerAddr, std::unique_ptr< HTTPCodec > codec, const wangle::TransportInfo &tinfo, InfoCallback *infoCallback, uint8_t maxVirtualPri=0, std::shared_ptr< const PriorityMapFactory > priorityMapFactory=std::shared_ptr< const PriorityMapFactory >())

	HTTPUpstreamSession (folly::HHWheelTimer timeout, folly::AsyncTransportWrapper::UniquePtr &&sock, const folly::SocketAddress &localAddr, const folly::SocketAddress &peerAddr, std::unique_ptr< HTTPCodec > codec, const wangle::TransportInfo &tinfo, InfoCallback infoCallback, uint8_t maxVirtualPri=0, std::shared_ptr< const PriorityMapFactory > priorityMapFactory=std::shared_ptr< const PriorityMapFactory >())

void	detachTransactions ()

bool	isDetachable (bool checkSocket=true) const override

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

void	detachThreadLocals (bool detachSSLContext=false) override

void	startNow () override

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

bool	isReplaySafe () const override

bool	isReusable () const override

bool	isClosing () const override

void	drain () override

virtual folly::Optional< const HTTPMessage::HTTPPriority >	getHTTPPriority (uint8_t level) override

Public Member Functions inherited from proxygen::HTTPSession
HTTPSessionBase::SessionType	getType () const noexceptoverride

folly::AsyncTransportWrapper *	getTransport () override

folly::EventBase *	getEventBase () const override

const folly::AsyncTransportWrapper *	getTransport () const override

bool	hasActiveTransactions () const override

uint32_t	getNumOutgoingStreams () const override

uint32_t	getNumIncomingStreams () const override

ByteEventTracker *	getByteEventTracker ()

void	setByteEventTracker (std::shared_ptr< ByteEventTracker > byteEventTracker)

void	setSessionStats (HTTPSessionStats *stats) override

void	setFlowControl (size_t initialReceiveWindow, size_t receiveStreamWindowSize, size_t receiveSessionWindowSize) override

void	setEgressSettings (const SettingsList &inSettings) override

bool	getHTTP2PrioritiesEnabled () const override

void	setHTTP2PrioritiesEnabled (bool enabled) override

const folly::SocketAddress &	getLocalAddress () const noexceptoverride

const folly::SocketAddress &	getPeerAddress () const noexceptoverride

const wangle::TransportInfo &	getSetupTransportInfo () const noexceptoverride

bool	getCurrentTransportInfo (wangle::TransportInfo *tinfo) override

void	setMaxConcurrentIncomingStreams (uint32_t num) override

void	setEgressBytesLimit (uint64_t bytesLimit)

size_t	sendSettings () override

size_t	sendPing () override

HTTPCodec::StreamID	sendPriority (http2::PriorityUpdate pri) override

size_t	sendPriority (HTTPCodec::StreamID id, http2::PriorityUpdate pri) override

size_t	sendCertificateRequest (std::unique_ptr< folly::IOBuf > certificateRequestContext, std::vector< fizz::Extension > extensions) override

void	timeoutExpired () noexceptoverride

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

bool	isBusy () const override

void	notifyPendingShutdown () override

void	closeWhenIdle () override

void	dropConnection () override

void	dumpConnectionState (uint8_t loglevel) override

bool	getCurrentTransportInfoWithoutUpdate (wangle::TransportInfo *tinfo) const override

void	setHeaderCodecStats (HeaderCodec::Stats *stats) override

void	enableDoubleGoawayDrain () override

bool	connCloseByRemote () override

void	setSecondAuthManager (std::unique_ptr< SecondaryAuthManager > secondAuthManager)

SecondaryAuthManager *	getSecondAuthManager () const

Public Member Functions inherited from proxygen::HTTPSessionBase
	HTTPSessionBase (const folly::SocketAddress &localAddr, const folly::SocketAddress &peerAddr, HTTPSessionController controller, const wangle::TransportInfo &tinfo, InfoCallback infoCallback, std::unique_ptr< HTTPCodec > codec)

virtual	~HTTPSessionBase ()

void	setInfoCallback (InfoCallback *callback)

InfoCallback *	getInfoCallback () const

HTTPTransaction::Handler *	getParseErrorHandler (HTTPTransaction *txn, const HTTPException &error)

bool	supportsMoreTransactions () const

uint32_t	getHistoricalMaxOutgoingStreams () const

uint32_t	getMaxConcurrentOutgoingStreams () const

HTTPSessionController *	getController ()

void	setController (HTTPSessionController *controller)

ConnectionCloseReason	getConnectionCloseReason () const

template<typename Filter , typename... Args>
void	addCodecFilter (Args &&...args)

virtual CodecProtocol	getCodecProtocol () const

void	setHTTP2PrioritiesEnabled (bool enabled)

void	setMaxConcurrentOutgoingStreams (uint32_t num)

uint32_t	getWriteBufferLimit () const

void	setWriteBufferLimit (uint32_t limit)

void	setReadBufferLimit (uint32_t limit)

uint64_t	getNumTxnServed () const

std::chrono::seconds	getLatestIdleTime () const

void	setPrioritySampled (bool sampled)

const folly::SocketAddress &	getLocalAddress () const noexcept

const folly::SocketAddress &	getPeerAddress () const noexcept

const wangle::TransportInfo &	getSetupTransportInfo () const noexcept

wangle::TransportInfo &	getSetupTransportInfo () noexcept

void	enableExHeadersSettings () noexcept

bool	isExHeadersEnabled () noexcept

Public Member Functions inherited from wangle::ManagedConnection
	ManagedConnection ()

void	fireNotifyPendingShutdown ()

void	fireCloseWhenIdle (bool force_to_close=false)

virtual void	resetTimeout ()

void	resetTimeoutTo (std::chrono::milliseconds)

virtual void	scheduleTimeout (folly::HHWheelTimer::Callback *callback, std::chrono::milliseconds timeout)

ConnectionManager *	getConnectionManager ()

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::DelayedDestruction
virtual void	destroy ()

bool	getDestroyPending () const

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

Public Member Functions inherited from proxygen::HTTPTransaction::Transport
virtual	~Transport ()

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

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

Public Member Functions inherited from proxygen::ByteEventTracker::Callback
virtual	~Callback ()

Private Member Functions
	~HTTPUpstreamSession () override

void	setupOnHeadersComplete (HTTPTransaction , HTTPMessage ) override

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

bool	allTransactionsStarted () const override

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

void	maybeAttachSSLContext (folly::SSLContextPtr sslContext) const

void	maybeDetachSSLContext () const

Private Attributes
uint8_t	maxVirtualPriorityLevel_ {0}

std::shared_ptr< const PriorityMapFactory >	priorityMapFactory_

std::unique_ptr< PriorityAdapter >	priorityAdapter_

Additional Inherited Members
Static Public Member Functions inherited from proxygen::HTTPSessionBase
static void	setDefaultReadBufferLimit (uint32_t limit)

static void	setMaxReadBufferSize (uint32_t bytes)

static void	setFlowControlledBodySizeLimit (uint32_t limit)

static void	setDefaultWriteBufferLimit (uint32_t max)

Protected Member Functions inherited from proxygen::HTTPSession
	HTTPSession (const WheelTimerInstance &timeout, folly::AsyncTransportWrapper::UniquePtr sock, const folly::SocketAddress &localAddr, const folly::SocketAddress &peerAddr, HTTPSessionController controller, std::unique_ptr< HTTPCodec > codec, const wangle::TransportInfo &tinfo, InfoCallback infoCallback)

	HTTPSession (folly::HHWheelTimer transactionTimeouts, folly::AsyncTransportWrapper::UniquePtr sock, const folly::SocketAddress &localAddr, const folly::SocketAddress &peerAddr, HTTPSessionController controller, std::unique_ptr< HTTPCodec > codec, const wangle::TransportInfo &tinfo, InfoCallback *infoCallback)

	~HTTPSession () override

virtual void	onHeadersSent (const HTTPMessage &, bool)

void	setNewTransactionPauseState (HTTPCodec::StreamID streamID)

void	onEgressMessageFinished (HTTPTransaction *txn, bool withRST=false)

std::unique_ptr< folly::IOBuf >	getNextToSend (bool cork, bool eom)

void	decrementTransactionCount (HTTPTransaction *txn, bool ingressEOM, bool egressEOM)

size_t	getCodecSendWindowSize () const

size_t	sendPriorityImpl (HTTPCodec::StreamID streamID, http2::PriorityUpdate pri)

bool	onNativeProtocolUpgradeImpl (HTTPCodec::StreamID txn, std::unique_ptr< HTTPCodec > codec, const std::string &protocolString)

void	readTimeoutExpired () noexcept

void	writeTimeoutExpired () noexcept

void	flowControlTimeoutExpired () noexcept

void	getReadBuffer (void *buf, size_t bufSize) override

void	readDataAvailable (size_t readSize) noexceptoverride

bool	isBufferMovable () noexceptoverride

void	readBufferAvailable (std::unique_ptr< folly::IOBuf >) noexceptoverride

void	processReadData ()

void	readEOF () noexceptoverride

void	readErr (const folly::AsyncSocketException &) noexceptoverride

std::string	getSecurityProtocol () const override

void	onMessageBegin (HTTPCodec::StreamID streamID, HTTPMessage *msg) override

void	onPushMessageBegin (HTTPCodec::StreamID streamID, HTTPCodec::StreamID assocStreamID, HTTPMessage *msg) override

void	onExMessageBegin (HTTPCodec::StreamID streamID, HTTPCodec::StreamID controlStream, bool unidirectional, HTTPMessage *msg) override

void	onHeadersComplete (HTTPCodec::StreamID streamID, std::unique_ptr< HTTPMessage > msg) override

void	onBody (HTTPCodec::StreamID streamID, std::unique_ptr< folly::IOBuf > chain, uint16_t padding) override

void	onChunkHeader (HTTPCodec::StreamID stream, size_t length) override

void	onChunkComplete (HTTPCodec::StreamID stream) override

void	onTrailersComplete (HTTPCodec::StreamID streamID, std::unique_ptr< HTTPHeaders > trailers) override

void	onMessageComplete (HTTPCodec::StreamID streamID, bool upgrade) override

void	onError (HTTPCodec::StreamID streamID, const HTTPException &error, bool newTxn) override

void	onAbort (HTTPCodec::StreamID streamID, ErrorCode code) override

void	onGoaway (uint64_t lastGoodStreamID, ErrorCode code, std::unique_ptr< folly::IOBuf > debugData=nullptr) override

void	onPingRequest (uint64_t uniqueID) override

void	onPingReply (uint64_t uniqueID) override

void	onWindowUpdate (HTTPCodec::StreamID stream, uint32_t amount) override

void	onSettings (const SettingsList &settings) override

void	onSettingsAck () override

void	onPriority (HTTPCodec::StreamID stream, const HTTPMessage::HTTPPriority &) override

void	onCertificateRequest (uint16_t requestId, std::unique_ptr< folly::IOBuf > authRequest) override

void	onCertificate (uint16_t certId, std::unique_ptr< folly::IOBuf > authenticator) override

uint32_t	numOutgoingStreams () const override

uint32_t	numIncomingStreams () const override

void	pauseIngress (HTTPTransaction *txn) noexceptoverride

void	resumeIngress (HTTPTransaction *txn) noexceptoverride

void	transactionTimeout (HTTPTransaction *txn) noexceptoverride

void	sendHeaders (HTTPTransaction txn, const HTTPMessage &headers, HTTPHeaderSize size, bool includeEOM) noexceptoverride

size_t	sendBody (HTTPTransaction *txn, std::unique_ptr< folly::IOBuf >, bool includeEOM, bool trackLastByteFlushed) noexceptoverride

size_t	sendChunkHeader (HTTPTransaction *txn, size_t length) noexceptoverride

size_t	sendChunkTerminator (HTTPTransaction *txn) noexceptoverride

size_t	sendEOM (HTTPTransaction txn, const HTTPHeaders trailers) noexceptoverride

size_t	sendAbort (HTTPTransaction *txn, ErrorCode statusCode) noexceptoverride

size_t	sendPriority (HTTPTransaction *txn, const http2::PriorityUpdate &pri) noexceptoverride

void	detach (HTTPTransaction *txn) noexceptoverride

size_t	sendWindowUpdate (HTTPTransaction *txn, uint32_t bytes) noexceptoverride

void	notifyPendingEgress () noexceptoverride

void	notifyIngressBodyProcessed (uint32_t bytes) noexceptoverride

void	notifyEgressBodyBuffered (int64_t bytes) noexceptoverride

HTTPTransaction *	newPushedTransaction (HTTPCodec::StreamID assocStreamId, HTTPTransaction::PushHandler *handler) noexceptoverride

HTTPTransaction *	newExTransaction (HTTPTransaction::Handler *handler, HTTPCodec::StreamID controlStream, bool unidirectional=false) noexceptoverride

const HTTPCodec &	getCodec () const noexceptoverride

const folly::AsyncTransportWrapper *	getUnderlyingTransport () const noexceptoverride

bool	isDraining () const override

void	shutdownTransport (bool shutdownReads=true, bool shutdownWrites=true, const std::string &errorMsg="")

void	shutdownTransportWithReset (ProxygenError errorCode, const std::string &errorMsg="")

void	runLoopCallback () noexceptoverride

void	scheduleWrite ()

void	updateWriteCount ()

void	updateWriteBufSize (int64_t delta)

uint64_t	sessionByteOffset ()

void	immediateShutdown ()

void	checkForShutdown ()

HTTPTransaction *	findTransaction (HTTPCodec::StreamID streamID)

HTTPTransaction *	createTransaction (HTTPCodec::StreamID streamID, const folly::Optional< HTTPCodec::StreamID > &assocStreamID, const folly::Optional< HTTPCodec::ExAttributes > &exAttributes, const http2::PriorityUpdate &priority=http2::DefaultPriority)

void	onWriteSuccess (uint64_t bytesWritten)

void	onWriteError (size_t bytesWritten, const folly::AsyncSocketException &ex)

void	onWriteCompleted ()

void	pauseReads ()

void	onSessionParseError (const HTTPException &error)

void	onNewTransactionParseError (HTTPCodec::StreamID streamID, const HTTPException &error)

void	resumeReads ()

bool	hasMoreWrites () const

template<typename... Args1, typename... Args2>
void	invokeOnAllTransactions (void(HTTPTransaction::*fn)(Args1...), Args2 &&...args)

void	resumeTransactions ()

void	errorOnAllTransactions (ProxygenError err, const std::string &errorMsg)

void	errorOnTransactionIds (const std::vector< HTTPCodec::StreamID > &ids, ProxygenError err, const std::string &extraErrorMsg="")

void	errorOnTransactionId (HTTPCodec::StreamID id, HTTPException ex)

bool	shouldShutdown () const

void	drainImpl ()

void	pauseReadsImpl ()

void	resumeReadsImpl ()

bool	readsUnpaused () const

bool	readsPaused () const

bool	readsShutdown () const

bool	writesUnpaused () const

bool	writesPaused () const

bool	writesShutdown () const

void	rescheduleLoopCallbacks ()

void	cancelLoopCallbacks ()

Protected Member Functions inherited from proxygen::HTTPSessionBase
void	handleErrorDirectly (HTTPTransaction *txn, const HTTPException &error)

bool	onBodyImpl (std::unique_ptr< folly::IOBuf > chain, size_t length, uint16_t padding, HTTPTransaction *txn)

bool	notifyBodyProcessed (uint32_t bytes)

void	setLatestActive ()

bool	ingressLimitExceeded () const

bool	egressLimitExceeded () const

void	updatePendingWriteSize (int64_t delta)

void	onCreateTransaction ()

void	incrementSeqNo ()

bool	isPrioritySampled () const

void	onNewOutgoingStream (uint32_t outgoingStreams)

void	setCloseReason (ConnectionCloseReason reason)

void	runDestroyCallbacks ()

void	onCodecChanged ()

void	initCodecHeaderIndexingStrategy ()

void	attachToSessionController ()

Protected Member Functions inherited from wangle::ManagedConnection
	~ManagedConnection () override

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

Protected Member Functions inherited from folly::DelayedDestruction
	~DelayedDestruction () override=default

	DelayedDestruction ()

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

uint32_t	getDestructorGuardCount () const

Protected Member Functions inherited from folly::AsyncTransport::BufferCallback
virtual	~BufferCallback ()

Protected Member Functions inherited from proxygen::HTTPPriorityMapFactoryProvider
virtual	~HTTPPriorityMapFactoryProvider ()=default

Static Protected Member Functions inherited from proxygen::HTTPSessionBase
static void	handleLastByteEvents (ByteEventTracker byteEventTracker, HTTPTransaction txn, size_t encodedSize, size_t byteOffset, bool piggybacked)

Protected Attributes inherited from proxygen::HTTPSession
WriteTimeout	writeTimeout_

folly::IOBufQueue	writeBuf_ {folly::IOBufQueue::cacheChainLength()}

folly::IOBufQueue	readBuf_ {folly::IOBufQueue::cacheChainLength()}

HTTP2PriorityQueue	txnEgressQueue_

std::map< HTTPCodec::StreamID, HTTPTransaction >	transactions_

uint32_t	liveTransactions_ {0}

folly::AsyncTransportWrapper::UniquePtr	sock_

WheelTimerInstance	timeout_

unsigned	numActiveWrites_ {0}

bool	draining_:1

bool	started_:1

bool	writesDraining_:1

bool	resetAfterDrainingWrites_:1

bool	ingressError_:1

Protected Attributes inherited from proxygen::HTTPSessionBase
HTTPSessionStats *	sessionStats_ {nullptr}

InfoCallback *	infoCallback_ {nullptr}

wangle::TransportInfo	transportInfo_

HTTPCodecFilterChain	codec_

folly::SocketAddress	localAddr_

folly::SocketAddress	peerAddr_

Static Protected Attributes inherited from proxygen::HTTPSessionBase
static uint32_t	kDefaultReadBufLimit = 65536

static uint32_t	maxReadBufferSize_ = 4000

static uint32_t	kDefaultWriteBufLimit = 65536

static uint32_t	egressBodySizeLimit_ = 4096

Detailed Description

Definition at line 22 of file HTTPUpstreamSession.h.

Member Typedef Documentation

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

Definition at line 89 of file HTTPUpstreamSession.h.

Constructor & Destructor Documentation

proxygen::HTTPUpstreamSession::HTTPUpstreamSession	(	const WheelTimerInstance &	timeout,
		folly::AsyncTransportWrapper::UniquePtr &&	sock,
		const folly::SocketAddress &	localAddr,
		const folly::SocketAddress &	peerAddr,
		std::unique_ptr< HTTPCodec >	codec,
		const wangle::TransportInfo &	tinfo,
		InfoCallback *	infoCallback,
		uint8_t	maxVirtualPri = `0`,
		std::shared_ptr< const PriorityMapFactory >	priorityMapFactory = `std::shared_ptr<const PriorityMapFactory>()`
	)

inline

Parameters

sock	An open socket on which any applicable TLS handshaking has been completed already.
localAddr	Address and port of the local end of the socket.
peerAddr	Address and port of the remote end of the socket.
codec	A codec with which to parse/generate messages in whatever HTTP-like wire format this session needs.
maxVirtualPri	Number of virtual priority nodes to represent fixed priority levels.

Definition at line 34 of file HTTPUpstreamSession.h.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::getTransportDirection(), folly::AsyncSocket::setBufferCallback(), proxygen::HTTPSession::sock_, and proxygen::UPSTREAM.

                                                      :
     HTTPSession(
         timeout,
         std::move(sock),
         localAddr,
         peerAddr,
         nullptr,
         std::move(codec),
         tinfo,
         infoCallback),
     maxVirtualPriorityLevel_(priorityMapFactory ? 0 : maxVirtualPri),
     priorityMapFactory_(priorityMapFactory) {
     if (sock_) {
       auto asyncSocket = sock_->getUnderlyingTransport<folly::AsyncSocket>();
       if (asyncSocket) {
         asyncSocket->setBufferCallback(this);
       }
     }
     CHECK_EQ(codec_->getTransportDirection(), TransportDirection::UPSTREAM);
   }

proxygen::HTTPUpstreamSession::HTTPUpstreamSession	(	folly::HHWheelTimer *	timeout,
		folly::AsyncTransportWrapper::UniquePtr &&	sock,
		const folly::SocketAddress &	localAddr,
		const folly::SocketAddress &	peerAddr,
		std::unique_ptr< HTTPCodec >	codec,
		const wangle::TransportInfo &	tinfo,
		InfoCallback *	infoCallback,
		uint8_t	maxVirtualPri = `0`,
		std::shared_ptr< const PriorityMapFactory >	priorityMapFactory = `std::shared_ptr<const PriorityMapFactory>()`
	)

inline

Definition at line 66 of file HTTPUpstreamSession.h.

                                                      :
     HTTPUpstreamSession(
         WheelTimerInstance(timeout),
         std::move(sock),
         localAddr,
         peerAddr,
         std::move(codec),
         tinfo,
         infoCallback,
         maxVirtualPri,
         priorityMapFactory) {
   }

proxygen::HTTPUpstreamSession::~HTTPUpstreamSession ( )

overrideprivate

Definition at line 20 of file HTTPUpstreamSession.cpp.

Referenced by getHTTPPriority().

20 {}

Member Function Documentation

bool proxygen::HTTPUpstreamSession::allTransactionsStarted ( ) const

overrideprivatevirtual

Implements proxygen::HTTPSession.

Definition at line 119 of file HTTPUpstreamSession.cpp.

References proxygen::HTTPSession::transactions_.

Referenced by setupOnHeadersComplete().

                                                        {
   for (const auto& txn: transactions_) {
     if (!txn.second.isPushed() && !txn.second.isEgressStarted()) {
       return false;
     }
   }
   return true;
 }

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

overridevirtual

Implements proxygen::HTTPSessionBase.

Definition at line 174 of file HTTPUpstreamSession.cpp.

References proxygen::HTTP2PriorityQueue::attachThreadLocals(), proxygen::HTTPSessionBase::codec_, proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::foreach(), maybeAttachSSLContext(), proxygen::HTTPSession::rescheduleLoopCallbacks(), proxygen::HTTPSession::resumeReadsImpl(), proxygen::HTTPSessionBase::setController(), proxygen::HTTPCodec::setHeaderCodecStats(), proxygen::HTTPSession::setSessionStats(), proxygen::HTTPSession::sock_, proxygen::HTTPSession::timeout_, and proxygen::HTTPSession::txnEgressQueue_.

                                      {
   txnEgressQueue_.attachThreadLocals(timeout);
   timeout_ = timeout;
   setController(controller);
   setSessionStats(stats);
   if (sock_) {
     sock_->attachEventBase(eventBase);
     maybeAttachSSLContext(sslContext);
   }
   codec_.foreach(fn);
   codec_->setHeaderCodecStats(headerCodecStats);
   resumeReadsImpl();
   rescheduleLoopCallbacks();
 }

void proxygen::HTTPUpstreamSession::detachThreadLocals ( bool detachSSLContext = false )

overridevirtual

Implements proxygen::HTTPSessionBase.

Definition at line 206 of file HTTPUpstreamSession.cpp.

                                                              {
   CHECK(transactions_.empty());
   cancelLoopCallbacks();
   pauseReadsImpl();
   if (sock_) {
     if (detachSSLContext) {
       maybeDetachSSLContext();
     }
     sock_->detachEventBase();
   }
   txnEgressQueue_.detachThreadLocals();
   setController(nullptr);
   setSessionStats(nullptr);
   // The codec filters *shouldn't* be accessible while the socket is detached,
   // I hope
   codec_->setHeaderCodecStats(nullptr);
   auto cm = getConnectionManager();
   if (cm) {
     cm->removeConnection(this);
   }
 }

void proxygen::HTTPUpstreamSession::detachTransactions ( )

Definition at line 158 of file HTTPUpstreamSession.cpp.

References proxygen::HTTPSession::detach(), and proxygen::HTTPSession::transactions_.

                                              {
   while (!transactions_.empty()) {
     auto txn = transactions_.begin();
     detach(&txn->second);
   }
 }

void proxygen::HTTPUpstreamSession::drain ( )

inlineoverridevirtual

Drains the current transactions and prevents new transactions from being created on this session. When the number of transactions reaches zero, this session will shutdown the transport and delete itself.

Reimplemented from proxygen::HTTPSession.

Definition at line 137 of file HTTPUpstreamSession.h.

References proxygen::HTTPSession::drain().

Referenced by ProxyService::SessionWrapper::~SessionWrapper().

                         {
     HTTPSession::drain();
   }

virtual folly::Optional<const HTTPMessage::HTTPPriority> proxygen::HTTPUpstreamSession::getHTTPPriority ( uint8_t level )

inlineoverridevirtual

Reimplemented from proxygen::HTTPSession.

Definition at line 141 of file HTTPUpstreamSession.h.

References proxygen::HTTPSession::getHTTPPriority(), priorityAdapter_, and ~HTTPUpstreamSession().

                              {
    if (!priorityAdapter_) {
      return HTTPSession::getHTTPPriority(level);
    }
    return priorityAdapter_->getHTTPPriority(level);
  }

HTTPTransaction::Handler * proxygen::HTTPUpstreamSession::getTransactionTimeoutHandler ( HTTPTransaction * txn )

overrideprivatevirtual

Called by transactionTimeout() if the transaction has no handler.

Implements proxygen::HTTPSession.

Definition at line 113 of file HTTPUpstreamSession.cpp.

Referenced by setupOnHeadersComplete().

                         {
   // No special handler for upstream requests that time out
   return nullptr;
 }

bool proxygen::HTTPUpstreamSession::isClosing ( ) const

overridevirtual

Returns true if the session is shutting down

Implements proxygen::HTTPSessionBase.

Definition at line 52 of file HTTPUpstreamSession.cpp.

References proxygen::HTTPSession::draining_, proxygen::HTTPSession::readsShutdown(), proxygen::HTTPSession::resetAfterDrainingWrites_, proxygen::HTTPSession::sock_, proxygen::HTTPSession::writesDraining_, and proxygen::HTTPSession::writesShutdown().

Referenced by isReusable().

                                           {
   VLOG(5) << "isClosing: " << *this
     << ", sock_->good()=" << sock_->good()
     << ", draining_=" << draining_
     << ", readsShutdown()=" << readsShutdown()
     << ", writesShutdown()=" << writesShutdown()
     << ", writesDraining_=" << writesDraining_
     << ", resetAfterDrainingWrites_=" << resetAfterDrainingWrites_;
   return
     !sock_->good() ||
     draining_ ||
     readsShutdown() ||
     writesShutdown() ||
     writesDraining_ ||
     resetAfterDrainingWrites_;
 }

bool proxygen::HTTPUpstreamSession::isDetachable ( bool checkSocket = true ) const

overridevirtual

Implements proxygen::HTTPSessionBase.

Definition at line 165 of file HTTPUpstreamSession.cpp.

References proxygen::HTTPSession::getNumIncomingStreams(), proxygen::HTTPSession::sock_, proxygen::HTTPSession::transactions_, and proxygen::HTTPSession::writesPaused().

                                                              {
   if (checkSocket && sock_ && !sock_->isDetachable()) {
     return false;
   }
   return transactions_.size() == 0 && getNumIncomingStreams() == 0 &&
     !writesPaused();
 }

bool proxygen::HTTPUpstreamSession::isReplaySafe ( ) const

overridevirtual

Returns true if the underlying transport has completed full handshake.

Implements proxygen::HTTPSessionBase.

Definition at line 22 of file HTTPUpstreamSession.cpp.

References proxygen::HTTPSession::sock_.

                                              {
   return sock_ ? sock_->isReplaySafe() : false;
 }

bool proxygen::HTTPUpstreamSession::isReusable ( ) const

overridevirtual

Returns true if this session has no open transactions and the underlying transport can be used again in a new request.

Implements proxygen::HTTPSessionBase.

Definition at line 26 of file HTTPUpstreamSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPSession::hasMoreWrites(), proxygen::HTTPSession::ingressError_, proxygen::HTTPCodec::isBusy(), isClosing(), proxygen::HTTPCodec::isReusable(), folly::HHWheelTimer::Callback::isScheduled(), proxygen::HTTPSession::liveTransactions_, proxygen::HTTPSession::numActiveWrites_, proxygen::HTTPSession::sock_, proxygen::HTTPCodec::supportsParallelRequests(), and proxygen::HTTPSession::writeTimeout_.

                                            {
   VLOG(4) << "isReusable: " << *this
     << ", liveTransactions_=" << liveTransactions_
     << ", isClosing()=" << isClosing()
     << ", sock_->connecting()=" << sock_->connecting()
     << ", codec_->isReusable()=" << codec_->isReusable()
     << ", codec_->isBusy()=" << codec_->isBusy()
     << ", numActiveWrites_=" << numActiveWrites_
     << ", writeTimeout_.isScheduled()=" << writeTimeout_.isScheduled()
     << ", ingressError_=" << ingressError_
     << ", hasMoreWrites()=" << hasMoreWrites()
     << ", codec_->supportsParallelRequests()="
          << codec_->supportsParallelRequests();
   return
     !isClosing() &&
     !sock_->connecting() &&
     codec_->isReusable() &&
     !codec_->isBusy() &&
     !ingressError_ &&
     (codec_->supportsParallelRequests() || (
       // These conditions only apply to serial codec sessions
       !hasMoreWrites() &&
       liveTransactions_ == 0 &&
       !writeTimeout_.isScheduled()));
 }

void proxygen::HTTPUpstreamSession::maybeAttachSSLContext ( folly::SSLContextPtr sslContext ) const

private

Definition at line 195 of file HTTPUpstreamSession.cpp.

References proxygen::HTTPSession::sock_.

Referenced by attachThreadLocals(), and setupOnHeadersComplete().

                                          {
 #ifndef NO_ASYNCSSLSOCKET
   auto sslSocket = sock_->getUnderlyingTransport<folly::AsyncSSLSocket>();
   if (sslSocket && sslContext) {
     sslSocket->attachSSLContext(sslContext);
   }
 #endif
 }

void proxygen::HTTPUpstreamSession::maybeDetachSSLContext ( ) const

private

Definition at line 228 of file HTTPUpstreamSession.cpp.

References proxygen::HTTPSession::sock_.

Referenced by detachThreadLocals(), and setupOnHeadersComplete().

                                                       {
 #ifndef NO_ASYNCSSLSOCKET
   auto sslSocket = sock_->getUnderlyingTransport<folly::AsyncSSLSocket>();
   if (sslSocket) {
     sslSocket->detachSSLContext();
   }
 #endif
 }

HTTPTransaction * proxygen::HTTPUpstreamSession::newTransaction ( HTTPTransaction::Handler * handler )

overridevirtual

Creates a new transaction on this upstream session. Invoking this function also has the side-affect of starting reads after this event loop completes.

Parameters

handler The request handler to attach to this transaction. It must not be null.

Implements proxygen::HTTPSessionBase.

Definition at line 91 of file HTTPUpstreamSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::createStream(), proxygen::HTTPSession::createTransaction(), proxygen::HTTPSession::draining_, proxygen::HTTPCodec::NoExAttributes, proxygen::HTTPCodec::NoStream, proxygen::HTTPSession::setNewTransactionPauseState(), proxygen::HTTPSession::started_, startNow(), and proxygen::HTTPSessionBase::supportsMoreTransactions().

Referenced by CurlService::CurlClient::connectSuccess(), and ProxyService::ProxyHandler::connectSuccess().

                                                                    {
   if (!supportsMoreTransactions() || draining_) {
     // This session doesn't support any more parallel transactions
     return nullptr;
   }
 
   if (!started_) {
     startNow();
   }
 
   auto txn = createTransaction(codec_->createStream(), HTTPCodec::NoStream,
                                HTTPCodec::NoExAttributes);
 
   if (txn) {
     DestructorGuard dg(this);
     auto txnID = txn->getID();
     txn->setHandler(CHECK_NOTNULL(handler));
     setNewTransactionPauseState(txnID);
   }
   return txn;
 }

bool proxygen::HTTPUpstreamSession::onNativeProtocolUpgrade	(	HTTPCodec::StreamID	,
		CodecProtocol	,
		const std::string &	,
		HTTPMessage &
	)

overrideprivatevirtual

Called upon receipt of a valid protocol switch. Return false if protocol switch could not be completed.

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 128 of file HTTPUpstreamSession.cpp.

References proxygen::HTTPCodec::addPriorityNodes(), codec, proxygen::HTTPSessionBase::codec_, proxygen::HTTP_2, maxVirtualPriorityLevel_, folly::gen::move, proxygen::HTTPSession::onNativeProtocolUpgradeImpl(), proxygen::HTTPSession::scheduleWrite(), proxygen::HTTPSession::txnEgressQueue_, proxygen::UPSTREAM, and proxygen::HTTPSession::writeBuf_.

Referenced by setupOnHeadersComplete().

                 {
 
   VLOG(4) << *this << " onNativeProtocolUpgrade streamID=" << streamID <<
     " protocol=" << protocolString;
 
   if (protocol != CodecProtocol::HTTP_2) {
     return false;
   }
 
   // Create the new Codec
   std::unique_ptr<HTTPCodec> codec =
       std::make_unique<HTTP2Codec>(TransportDirection::UPSTREAM);
 
   bool ret = onNativeProtocolUpgradeImpl(streamID, std::move(codec),
                                          protocolString);
   if (ret) {
     auto bytes = codec_->addPriorityNodes(
       txnEgressQueue_,
       writeBuf_,
       maxVirtualPriorityLevel_);
     if (bytes) {
       scheduleWrite();
     }
   }
   return ret;
 }

void proxygen::HTTPUpstreamSession::setupOnHeadersComplete	(	HTTPTransaction *	,
		HTTPMessage *
	)

inlineoverrideprivatevirtual

Called by onHeadersComplete(). Currently a no-op for upstream.

Implements proxygen::HTTPSession.

Definition at line 155 of file HTTPUpstreamSession.h.

References allTransactionsStarted(), getTransactionTimeoutHandler(), maybeAttachSSLContext(), maybeDetachSSLContext(), onNativeProtocolUpgrade(), streamID, and string.

156 {}

void proxygen::HTTPUpstreamSession::startNow ( )

overridevirtual

Start reading from the transport and send any introductory messages to the remote side. This function must be called once per session to begin reads.

Reimplemented from proxygen::HTTPSession.

Definition at line 69 of file HTTPUpstreamSession.cpp.

References proxygen::HTTPCodec::addPriorityNodes(), proxygen::HTTPSessionBase::codec_, maxVirtualPriorityLevel_, priorityAdapter_, priorityMapFactory_, proxygen::HTTPSession::scheduleWrite(), proxygen::HTTPSession::startNow(), proxygen::HTTPSession::txnEgressQueue_, and proxygen::HTTPSession::writeBuf_.

Referenced by newTransaction().

                                    {
   // startNow in base class CHECKs this session has not started.
   HTTPSession::startNow();
   // Upstream specific:
   // create virtual priority nodes and send Priority frames to peer if necessary
   if (priorityMapFactory_) {
     priorityAdapter_ = priorityMapFactory_->createVirtualStreams(this);
     scheduleWrite();
   } else {
     // TODO/T17420249 Move this to the PriorityAdapter and remove it from the
     // codec.
     auto bytes = codec_->addPriorityNodes(
         txnEgressQueue_,
         writeBuf_,
         maxVirtualPriorityLevel_);
     if (bytes) {
       scheduleWrite();
     }
   }
 }

Member Data Documentation

uint8_t proxygen::HTTPUpstreamSession::maxVirtualPriorityLevel_ {0}

private

Definition at line 174 of file HTTPUpstreamSession.h.

Referenced by onNativeProtocolUpgrade(), and startNow().

std::unique_ptr<PriorityAdapter> proxygen::HTTPUpstreamSession::priorityAdapter_

private

Definition at line 177 of file HTTPUpstreamSession.h.

Referenced by getHTTPPriority(), and startNow().

std::shared_ptr<const PriorityMapFactory> proxygen::HTTPUpstreamSession::priorityMapFactory_

private

Definition at line 176 of file HTTPUpstreamSession.h.

Referenced by startNow().

The documentation for this class was generated from the following files:

proxygen/lib/http/session/HTTPUpstreamSession.h
proxygen/lib/http/session/HTTPUpstreamSession.cpp

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation