proxygen: proxygen::HTTPSession Class Reference

Definition at line 435 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::getCodecProtocolString(), getLocalAddress(), getPeerAddress(), proxygen::HTTPCodec::getProtocol(), proxygen::HTTPCodec::getUserAgent(), and isDownstream().

Referenced by timeoutExpired().

                                           {
   os << "proto=" << getCodecProtocolString(codec_->getProtocol());
   if (isDownstream()) {
     os << ", UA=" << codec_->getUserAgent()
        << ", downstream=" << getPeerAddress() << ", " << getLocalAddress()
        << "=local";
   } else {
     os << ", local=" << getLocalAddress() << ", " << getPeerAddress()
        << "=upstream";
   }
 }

void proxygen::HTTPSession::detach ( HTTPTransaction * txn )

overrideprotectedvirtualnoexcept

References checkForShutdown(), decrementTransactionCount(), findTransaction(), wangle::ManagedConnection::getConnectionManager(), getPipelineStreamCount(), folly::gen::guard(), hasMoreWrites(), proxygen::HTTPSessionBase::infoCallback_, folly::HHWheelTimer::Callback::isScheduled(), liveTransactions_, maybeResumePausedPipelinedTransaction(), proxygen::HTTPSessionBase::InfoCallback::onDeactivateConnection(), wangle::ConnectionManager::onDeactivated(), proxygen::HTTPSessionBase::InfoCallback::onTransactionDetached(), readsShutdown(), proxygen::HTTPTransaction::removeExTransaction(), proxygen::HTTPTransaction::removePushedTransaction(), wangle::ManagedConnection::resetTimeout(), resumeIngress(), resumeReads(), proxygen::HTTPSessionBase::setLatestActive(), shouldShutdown(), shutdownTransport(), streamID, transactions_, writesDraining_, and writesShutdown().

Definition at line 1896 of file HTTPSession.cpp.

Referenced by proxygen::HTTPUpstreamSession::detachTransactions(), numIncomingStreams(), and proxygen::HTTPSession::WriteSegment::setEOR().

                                                  {
   DestructorGuard guard(this);
   HTTPCodec::StreamID streamID = txn->getID();
   auto txnSeqn = txn->getSequenceNumber();
   auto it = transactions_.find(txn->getID());
   DCHECK(it != transactions_.end());
 
   if (txn->isIngressPaused()) {
     // Someone detached a transaction that was paused.  Make the resumeIngress
     // call to keep liveTransactions_ in order
     VLOG(4) << *this << " detached paused transaction=" << streamID;
     resumeIngress(txn);
   }
 
   VLOG(4) << *this << " removing streamID=" << streamID <<
     ", liveTransactions was " << liveTransactions_;
   CHECK_GT(liveTransactions_, 0);
   liveTransactions_--;
 
   if (txn->isPushed()) {
     auto assocTxn = findTransaction(*txn->getAssocTxnId());
     if (assocTxn) {
       assocTxn->removePushedTransaction(streamID);
     }
   }
   if (txn->getControlStream()) {
     auto controlTxn = findTransaction(*txn->getControlStream());
     if (controlTxn) {
       controlTxn->removeExTransaction(streamID);
     }
   }
 
   auto oldStreamCount = getPipelineStreamCount();
   decrementTransactionCount(txn, true, true);
   transactions_.erase(it);
 
   if (transactions_.empty()) {
     HTTPSessionBase::setLatestActive();
     if (infoCallback_) {
       infoCallback_->onDeactivateConnection(*this);
     }
     if (getConnectionManager()) {
       getConnectionManager()->onDeactivated(*this);
     }
   } else {
     if (infoCallback_) {
       infoCallback_->onTransactionDetached(*this);
     }
   }
 
   if (!readsShutdown()) {
     if (maybeResumePausedPipelinedTransaction(oldStreamCount, txnSeqn)) {
       return;
     } else {
       // this will resume reads if they were paused (eg: 0 HTTP transactions)
       resumeReads();
     }
   }
 
   if (liveTransactions_ == 0 && transactions_.empty() && !isScheduled()) {
     resetTimeout();
   }
 
   // It's possible that this is the last transaction in the session,
   // so check whether the conditions for shutdown are satisfied.
   if (transactions_.empty()) {
     if (shouldShutdown()) {
       writesDraining_ = true;
     }
     // Handle the case where we are draining writes but all remaining
     // transactions terminated with no egress.
     if (writesDraining_ && !writesShutdown() && !hasMoreWrites()) {
       shutdownTransport(false, true);
       return;
     }
   }
   checkForShutdown();
 }

void proxygen::HTTPSession::drain ( )

overrideprotectedvirtual

Drains the current transactions and prevents new transactions from being created on this session. If this is an upstream session and the number of transactions reaches zero, this session will shutdown the transport and delete itself. For downstream sessions, an explicit call to dropConnection() or shutdownTransport() is required.

Implements proxygen::HTTPSessionBase.

Reimplemented in proxygen::HTTPUpstreamSession.

Definition at line 2462 of file HTTPSession.cpp.

References allTransactionsStarted(), drainImpl(), draining_, isUpstream(), proxygen::HTTPSessionBase::setCloseReason(), proxygen::SHUTDOWN, shutdownTransport(), and transactions_.

Referenced by closeWhenIdle(), proxygen::HTTPUpstreamSession::drain(), isDraining(), notifyPendingShutdown(), and onGoaway().

                    {
   if (!draining_) {
     VLOG(4) << *this << " draining";
     draining_ = true;
     setCloseReason(ConnectionCloseReason::SHUTDOWN);
 
     if (allTransactionsStarted()) {
       drainImpl();
     }
     if (transactions_.empty() && isUpstream()) {
       // We don't do this for downstream since we need to wait for
       // inflight requests to arrive
       VLOG(4) << *this << " shutdown from drain";
       shutdownTransport(true, true);
     }
   } else {
     VLOG(4) << *this << " already draining";
   }
 }

void proxygen::HTTPSession::drainImpl ( )

protected

Definition at line 2482 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::generateGoaway(), getGracefulGoawayAck(), proxygen::HTTPCodec::isReusable(), proxygen::HTTPCodec::isWaitingToDrain(), proxygen::NO_ERROR, scheduleWrite(), proxygen::HTTPSessionBase::setCloseReason(), proxygen::SHUTDOWN, started_, and writeBuf_.

Referenced by drain(), invokeOnAllTransactions(), and sendHeaders().

                             {
   if (codec_->isReusable() || codec_->isWaitingToDrain()) {
     setCloseReason(ConnectionCloseReason::SHUTDOWN);
     // For HTTP/2, if we haven't started yet then we cannot send a GOAWAY frame
     // since we haven't sent the initial SETTINGS frame. Defer sending that
     // GOAWAY until the initial SETTINGS is sent.
     if (started_) {
       codec_->generateGoaway(writeBuf_,
                              getGracefulGoawayAck(),
                              ErrorCode::NO_ERROR);
       scheduleWrite();
     }
   }
 }

void proxygen::HTTPSession::dropConnection ( )

overridevirtual

Forcibly drop a connection.

If a request is in progress, this should cause the connection to be closed with a reset.

Implements wangle::ManagedConnection.

Definition at line 493 of file HTTPSession.cpp.

References hasMoreWrites(), immediateShutdown(), proxygen::kErrorDropped, readsShutdown(), proxygen::HTTPSessionBase::setCloseReason(), proxygen::SHUTDOWN, shutdownTransport(), shutdownTransportWithReset(), sock_, transactions_, and writesShutdown().

Referenced by closeWhenIdle(), and timeoutExpired().

                             {
   VLOG(4) << "dropping " << *this;
   if (!sock_ || (readsShutdown() && writesShutdown())) {
     VLOG(4) << *this << " already shutdown";
     return;
   }
 
   setCloseReason(ConnectionCloseReason::SHUTDOWN);
   if (transactions_.empty() && !hasMoreWrites()) {
     DestructorGuard dg(this);
     shutdownTransport(true, true);
     // shutdownTransport might have generated a write (goaway)
     // If so, writes will not be shutdown, so fall through to
     // shutdownTransportWithReset.
     if (readsShutdown() && writesShutdown()) {
       immediateShutdown();
       return;
     }
   }
   shutdownTransportWithReset(kErrorDropped);
 }

void proxygen::HTTPSession::dumpConnectionState ( uint8_t loglevel )

overridevirtual

Dump the state of the connection to the log

Implements wangle::ManagedConnection.

Definition at line 515 of file HTTPSession.cpp.

Referenced by timeoutExpired().

515 {}

void proxygen::HTTPSession::enableDoubleGoawayDrain ( )

inlineoverridevirtual

Implements proxygen::HTTPSessionBase.

Definition at line 208 of file HTTPSession.h.

References proxygen::HTTPSessionBase::codec_, and proxygen::HTTPCodec::enableDoubleGoawayDrain().

                                           {
     codec_->enableDoubleGoawayDrain();
   }

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

protected

This function invokes a callback on all transactions. It is safe, but runs in O(n*log n) and if the callback adds transactions, they will not get the callback.

Definition at line 2812 of file HTTPSession.cpp.

References errorOnTransactionIds(), and transactions_.

Referenced by invokeOnAllTransactions(), and shutdownTransportWithReset().

                                {
   std::vector<HTTPCodec::StreamID> ids;
   for (const auto& txn: transactions_) {
     ids.push_back(txn.first);
   }
   errorOnTransactionIds(ids, err, errorMsg);
 }

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

protected

Definition at line 2841 of file HTTPSession.cpp.

References findTransaction(), and folly::gen::move.

Referenced by errorOnTransactionIds(), invokeOnAllTransactions(), and onGoaway().

                       {
   auto txn = findTransaction(id);
   if (txn != nullptr) {
     txn->onError(std::move(ex));
   }
 }

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

protected

Definition at line 2822 of file HTTPSession.cpp.

References errorOnTransactionId(), proxygen::getErrorString(), proxygen::HTTPException::INGRESS_AND_EGRESS, folly::gen::move, proxygen::Exception::setProxygenError(), and string.

Referenced by errorOnAllTransactions(), invokeOnAllTransactions(), and onGoaway().

                              {
   std::string extraErrorMsg;
   if (!errorMsg.empty()) {
     extraErrorMsg = folly::to<std::string>(". ", errorMsg);
   }
 
   for (auto id: ids) {
     HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS,
       folly::to<std::string>(getErrorString(err),
         " on transaction id: ", id,
         extraErrorMsg));
     ex.setProxygenError(err);
     errorOnTransactionId(id, std::move(ex));
   }
 }

HTTPTransaction * proxygen::HTTPSession::findTransaction ( HTTPCodec::StreamID streamID )

protected

Get the HTTPTransaction for the given transaction ID, or nullptr if that transaction ID does not exist within this HTTPSession.

Definition at line 2545 of file HTTPSession.cpp.

References transactions_.

Referenced by detach(), errorOnTransactionId(), invokeOnAllTransactions(), onAbort(), onBody(), onChunkComplete(), onChunkHeader(), onError(), onExMessageBegin(), onHeadersComplete(), onMessageBegin(), onMessageComplete(), proxygen::HTTPDownstreamSession::onNativeProtocolUpgrade(), onNativeProtocolUpgradeImpl(), onPriority(), onPushMessageBegin(), onTrailersComplete(), onWindowUpdate(), pauseIngress(), resumeIngress(), sessionByteOffset(), and setNewTransactionPauseState().

                                                        {
   auto it = transactions_.find(streamID);
   if (it == transactions_.end()) {
     return nullptr;
   } else {
     return &it->second;
   }
 }

void proxygen::HTTPSession::flowControlTimeoutExpired ( )

protectednoexcept

Definition at line 425 of file HTTPSession.cpp.

References g(), proxygen::HTTPSessionBase::setCloseReason(), shutdownTransport(), and proxygen::TIMEOUT.

Referenced by getHTTPPriority(), and proxygen::HTTPSession::FlowControlTimeout::timeoutExpired().

                                                 {
   VLOG(4) << "Flow control timeout for " << *this;
 
   DestructorGuard g(this);
 
   setCloseReason(ConnectionCloseReason::TIMEOUT);
   shutdownTransport(true, true);
 }

ByteEventTracker* proxygen::HTTPSession::getByteEventTracker ( )

inline

Definition at line 88 of file HTTPSession.h.

References byteEventTracker_, setByteEventTracker(), setEgressSettings(), setFlowControl(), and setSessionStats().

88 { return byteEventTracker_.get(); }

proxygen::HTTPSession::byteEventTracker_

std::shared_ptr< ByteEventTracker > byteEventTracker_

Definition: HTTPSession.h:966

uint32_t proxygen::HTTPSession::getCertAuthSettingVal ( )

private

Definition at line 185 of file HTTPSession.cpp.

References folly::IOBuf::computeChainDataLength(), fizz::extensions::test::ekm, getTransport(), folly::AsyncTransportWrapper::getUnderlyingTransport(), isUpstream(), fizz::test::label, uint16_t, and uint32_t.

Referenced by getMaxConcurrentOutgoingStreamsRemote(), and setupCodec().

                                             {
   uint32_t certAuthSettingVal = 0;
   constexpr uint16_t settingLen = 4;
   std::unique_ptr<folly::IOBuf> ekm;
   folly::StringPiece label;
   if (isUpstream()) {
     label = kClientLabel;
   } else {
     label = kServerLabel;
   }
   auto fizzBase = getTransport()->getUnderlyingTransport<AsyncFizzBase>();
   if (fizzBase) {
     ekm = fizzBase->getEkm(label, nullptr, settingLen);
   } else {
     VLOG(4) << "Underlying transport does not support secondary "
                "authentication.";
     return certAuthSettingVal;
   }
   if (ekm && ekm->computeChainDataLength() == settingLen) {
     folly::io::Cursor cursor(ekm.get());
     uint32_t ekmVal = cursor.readBE<uint32_t>();
     certAuthSettingVal = (ekmVal & 0x3fffffff) | 0x80000000;
   }
   return certAuthSettingVal;
 }

const HTTPCodec& proxygen::HTTPSession::getCodec ( ) const

inlineoverrideprotectedvirtualnoexcept

References wangle::TransportInfo::appProtocol, getCurrentTransportInfoWithoutUpdate(), wangle::TransportInfo::rtt, wangle::TransportInfo::rtx, wangle::TransportInfo::secure, wangle::TransportInfo::setupTime, wangle::TransportInfo::sslCipher, wangle::TransportInfo::sslError, wangle::TransportInfo::sslResume, wangle::TransportInfo::sslSetupTime, wangle::TransportInfo::sslVersion, and proxygen::HTTPSessionBase::transportInfo_.

Definition at line 438 of file HTTPSession.h.

References proxygen::HTTPSessionBase::codec_, and proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::getChainEnd().

                                                       {
     return codec_.getChainEnd();
   }

size_t proxygen::HTTPSession::getCodecSendWindowSize ( ) const

protected

Definition at line 712 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::getDefaultWindowSize(), proxygen::HTTPCodec::getIngressSettings(), proxygen::HTTPSettings::getSetting(), proxygen::INITIAL_WINDOW_SIZE, and settings.

Referenced by createTransaction(), onHeadersSent(), and onNativeProtocolUpgradeImpl().

                                                  {
   const HTTPSettings* settings = codec_->getIngressSettings();
   if (settings) {
     return settings->getSetting(SettingsId::INITIAL_WINDOW_SIZE,
                                 codec_->getDefaultWindowSize());
   }
   return codec_->getDefaultWindowSize();
 }

bool proxygen::HTTPSession::getCurrentTransportInfo ( wangle::TransportInfo * tinfo )

overridevirtual

Implements proxygen::HTTPSessionBase.

Definition at line 2019 of file HTTPSession.cpp.

Referenced by getSetupTransportInfo().

                                                               {
   if (getCurrentTransportInfoWithoutUpdate(tinfo)) {
     // some fields are the same with the setup transport info
     tinfo->setupTime = transportInfo_.setupTime;
     tinfo->secure = transportInfo_.secure;
     tinfo->sslSetupTime = transportInfo_.sslSetupTime;
     tinfo->sslVersion = transportInfo_.sslVersion;
     tinfo->sslCipher = transportInfo_.sslCipher;
     tinfo->sslResume = transportInfo_.sslResume;
     tinfo->appProtocol = transportInfo_.appProtocol;
     tinfo->sslError = transportInfo_.sslError;
 #if defined(__linux__) || defined(__FreeBSD__)
     // update connection transport info with the latest RTT
     if (tinfo->tcpinfo.tcpi_rtt > 0) {
       transportInfo_.tcpinfo.tcpi_rtt = tinfo->tcpinfo.tcpi_rtt;
       transportInfo_.rtt = std::chrono::microseconds(tinfo->tcpinfo.tcpi_rtt);
     }
     transportInfo_.rtx = tinfo->rtx;
 #endif
     return true;
   }
   return false;
 }

bool proxygen::HTTPSession::getCurrentTransportInfoWithoutUpdate ( wangle::TransportInfo * tinfo ) const

overridevirtual

Implements proxygen::HTTPSessionBase.

Definition at line 2009 of file HTTPSession.cpp.

References wangle::TransportInfo::initWithSocket(), and sock_.

Referenced by getCurrentTransportInfo(), and timeoutExpired().

                                 {
   auto sock = sock_->getUnderlyingTransport<AsyncSocket>();
   if (sock) {
     tinfo->initWithSocket(sock);
     return true;
   }
   return false;
 }

folly::EventBase* proxygen::HTTPSession::getEventBase ( ) const

inlineoverridevirtual

Implements proxygen::HTTPSessionBase.

Definition at line 65 of file HTTPSession.h.

References sock_.

                                                 {
     if (sock_) {
       return sock_->getEventBase();
     }
     return nullptr;
   }

HTTPCodec::StreamID proxygen::HTTPSession::getGracefulGoawayAck ( ) const

private

Get the id of the stream we should ack in a graceful GOAWAY

Definition at line 2899 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::getLastIncomingStreamID(), proxygen::HTTPCodec::isReusable(), proxygen::HTTPCodec::isWaitingToDrain(), and max.

Referenced by drainImpl(), getMaxConcurrentOutgoingStreamsRemote(), and startNow().

                                                           {
   if (!codec_->isReusable() || codec_->isWaitingToDrain()) {
     // TODO: just track last stream ID inside HTTPSession since this logic
     // is shared between HTTP/2 and SPDY
     return codec_->getLastIncomingStreamID();
   }
   VLOG(4) << *this << " getGracefulGoawayAck is reusable and not draining";
   // return the maximum possible stream id
   return std::numeric_limits<int32_t>::max();
 }

bool proxygen::HTTPSession::getHTTP2PrioritiesEnabled ( ) const

inlineoverridevirtual

Reimplemented from proxygen::HTTPSessionBase.

Definition at line 114 of file HTTPSession.h.

References proxygen::HTTPSessionBase::getHTTP2PrioritiesEnabled().

Referenced by getMessagePriority(), onPriority(), and sendHeaders().

                                                   {
     return HTTPSessionBase::getHTTP2PrioritiesEnabled();
   }

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

inlineoverrideprotectedvirtual

Implements proxygen::HTTPSessionBase.

Reimplemented in proxygen::HTTPUpstreamSession.

Definition at line 339 of file HTTPSession.h.

References flowControlTimeoutExpired(), getReadBuffer(), isBufferMovable(), folly::pushmi::__adl::noexcept(), folly::none, processReadData(), readBufferAvailable(), readDataAvailable(), readEOF(), readErr(), readTimeoutExpired(), and writeTimeoutExpired().

Referenced by proxygen::HTTPUpstreamSession::getHTTPPriority().

                       {
     return folly::none;
   }

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

inlineoverridevirtualnoexcept

References proxygen::HTTPSessionBase::codec_, proxygen::http2::DefaultPriority, proxygen::http2::PriorityUpdate::exclusive, getHTTP2PrioritiesEnabled(), proxygen::HTTPMessage::getHTTP2Priority(), proxygen::HTTPMessage::getPriority(), proxygen::HTTPCodec::mapPriorityToDependency(), proxygen::http2::PriorityUpdate::streamDependency, and proxygen::http2::PriorityUpdate::weight.

Definition at line 122 of file HTTPSession.h.

References proxygen::HTTPSessionBase::getLocalAddress().

Referenced by describe(), and proxygen::HTTPDownstreamSession::getTransactionTimeoutHandler().

                                                                       {
     return HTTPSessionBase::getLocalAddress();
   }

uint32_t proxygen::HTTPSession::getMaxConcurrentOutgoingStreamsRemote ( ) const

inlineoverrideprivatevirtual

Implements proxygen::HTTPSessionBase.

Definition at line 720 of file HTTPSession.h.

References proxygen::_SPDY_INVALID_STREAM, addAckToLastByteEvent(), addLastByteEvent(), getCertAuthSettingVal(), getGracefulGoawayAck(), getMessagePriority(), invalidStream(), isDownstream(), isUpstream(), maxConcurrentOutgoingStreamsRemote_, folly::pushmi::__adl::noexcept(), onConnectionSendWindowClosed(), onConnectionSendWindowOpen(), onEgressBufferCleared(), onEgressBuffered(), onSetMaxInitiatedStreams(), onSetSendWindow(), setupCodec(), uint32_t, uint64_t, value, and verifyCertAuthSetting().

                                                                   {
     return maxConcurrentOutgoingStreamsRemote_;
   }

http2::PriorityUpdate proxygen::HTTPSession::getMessagePriority ( const HTTPMessage * msg )

private

Definition at line 737 of file HTTPSession.cpp.

Referenced by getMaxConcurrentOutgoingStreamsRemote(), onExMessageBegin(), onMessageBegin(), onPushMessageBegin(), and sendHeaders().

                                                       {
   http2::PriorityUpdate h2Pri = http2::DefaultPriority;
 
   // if HTTP2 priorities are enabled, get them from the message
   // and ignore otherwise
   if (getHTTP2PrioritiesEnabled() && msg) {
     auto res = msg->getHTTP2Priority();
     if (res) {
       h2Pri.streamDependency = std::get<0>(*res);
       h2Pri.exclusive = std::get<1>(*res);
       h2Pri.weight = std::get<2>(*res);
     } else {
       // HTTPMessage with setPriority called explicitly
       h2Pri.streamDependency =
         codec_->mapPriorityToDependency(msg->getPriority());
     }
   }
   return h2Pri;
 }

unique_ptr< IOBuf > proxygen::HTTPSession::getNextToSend	(	bool *	cork,
		bool *	eom
	)

protected

Gets the next IOBuf to send (either writeBuf_ or new egress from the priority queue), and sets cork appropriately

Definition at line 2043 of file HTTPSession.cpp.

References byteEventTracker_, bytesWritten_, folly::IOBufQueue::chainLength(), proxygen::HTTPSessionBase::codec_, connFlowControl_, proxygen::HTTPSessionBase::egressBodySizeLimit_, proxygen::HTTP2PriorityQueue::empty(), folly::IOBufQueue::empty(), proxygen::FlowControlFilter::getAvailableSend(), proxygen::HTTPCodec::getProtocol(), isConnWindowFull(), proxygen::isSpdyCodecProtocol(), min, folly::IOBufQueue::move(), proxygen::HTTP2PriorityQueue::nextEgress(), nextEgressResults_, numActiveWrites_, proxygen::TTLBAStats::recordTTLBAIOBSplitByEom(), proxygen::HTTPSessionBase::sessionStats_, folly::IOBufQueue::split(), txnEgressQueue_, uint32_t, uint64_t, writeBuf_, and writesShutdown().

Referenced by onHeadersSent(), and runLoopCallback().

                                                                   {
   // limit ourselves to one outstanding write at a time (onWriteSuccess calls
   // scheduleWrite)
   if (numActiveWrites_ > 0 || writesShutdown()) {
     VLOG(4) << "skipping write during this loop, numActiveWrites_=" <<
       numActiveWrites_ << " writesShutdown()=" << writesShutdown();
     return nullptr;
   }
 
   // We always tack on at least one body packet to the current write buf
   // This ensures that a short HTTPS response will go out in a single SSL record
   while (!txnEgressQueue_.empty()) {
     uint32_t toSend = kWriteReadyMax;
     if (connFlowControl_) {
       if (connFlowControl_->getAvailableSend() == 0) {
         VLOG(4) << "Session-level send window is full, skipping remaining "
                 << "body writes this loop";
         break;
       }
       toSend = std::min(toSend, connFlowControl_->getAvailableSend());
     }
     txnEgressQueue_.nextEgress(nextEgressResults_,
                                isSpdyCodecProtocol(codec_->getProtocol()));
     CHECK(!nextEgressResults_.empty()); // Queue was non empty, so this must be
     // The maximum we will send for any transaction in this loop
     uint32_t txnMaxToSend = toSend * nextEgressResults_.front().second;
     if (txnMaxToSend == 0) {
       // toSend is smaller than the number of transactions.  Give all egress
       // to the first transaction
       nextEgressResults_.erase(++nextEgressResults_.begin(),
                                nextEgressResults_.end());
       txnMaxToSend = std::min(toSend, egressBodySizeLimit_);
       nextEgressResults_.front().second = 1;
     }
     if (nextEgressResults_.size() > 1 && txnMaxToSend > egressBodySizeLimit_) {
       // Cap the max to egressBodySizeLimit_, and recompute toSend accordingly
       txnMaxToSend = egressBodySizeLimit_;
       toSend = txnMaxToSend / nextEgressResults_.front().second;
     }
     // split allowed by relative weight, with some minimum
     for (auto txnPair: nextEgressResults_) {
       uint32_t txnAllowed = txnPair.second * toSend;
       if (nextEgressResults_.size() > 1) {
         CHECK_LE(txnAllowed, egressBodySizeLimit_);
       }
       if (connFlowControl_) {
         CHECK_LE(txnAllowed, connFlowControl_->getAvailableSend());
       }
       if (txnAllowed == 0) {
         // The ratio * toSend was so small this txn gets nothing.
         VLOG(4) << *this << " breaking egress loop on 0 txnAllowed";
         break;
       }
 
       VLOG(4) << *this << " egressing txnID=" << txnPair.first->getID() <<
         " allowed=" << txnAllowed;
       txnPair.first->onWriteReady(txnAllowed, txnPair.second);
     }
     nextEgressResults_.clear();
     // it can be empty because of HTTPTransaction rate limiting.  We should
     // change rate limiting to clearPendingEgress while waiting.
     if (!writeBuf_.empty()) {
       break;
     }
   }
   *eom = false;
   if (byteEventTracker_) {
     uint64_t needed = byteEventTracker_->preSend(cork, eom, bytesWritten_);
     if (needed > 0) {
       VLOG(5) << *this << " writeBuf_.chainLength(): "
               << writeBuf_.chainLength() << " txnEgressQueue_.empty(): "
               << txnEgressQueue_.empty();
 
       if (needed < writeBuf_.chainLength()) {
         // split the next EOM chunk
         VLOG(5) << *this << " splitting " << needed << " bytes out of a "
                 << writeBuf_.chainLength() << " bytes IOBuf";
         *cork = true;
         if (sessionStats_) {
           sessionStats_->recordTTLBAIOBSplitByEom();
         }
         return writeBuf_.split(needed);
       } else {
         CHECK_EQ(needed, writeBuf_.chainLength());
       }
     }
   }
 
   // cork if there are txns with pending egress and room to send them
   *cork = !txnEgressQueue_.empty() && !isConnWindowFull();
   return writeBuf_.move();
 }

uint32_t proxygen::HTTPSession::getNumIncomingStreams ( ) const

inlineoverridevirtual

Implements proxygen::HTTPSessionBase.

Definition at line 84 of file HTTPSession.h.

References incomingStreams_.

Referenced by proxygen::HTTPUpstreamSession::isDetachable().

                                                   {
     return incomingStreams_;
   }

uint32_t proxygen::HTTPSession::getNumOutgoingStreams ( ) const

inlineoverridevirtual

Implements proxygen::HTTPSessionBase.

Definition at line 80 of file HTTPSession.h.

References outgoingStreams_.

                                                   {
     return outgoingStreams_;
   }

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

inlineoverridevirtualnoexcept

Definition at line 126 of file HTTPSession.h.

References proxygen::HTTPSessionBase::getPeerAddress().

Referenced by describe(), and shutdownTransport().

                                                                      {
     return HTTPSessionBase::getPeerAddress();
   }

size_t proxygen::HTTPSession::getPipelineStreamCount ( ) const

inlineprivate

Definition at line 835 of file HTTPSession.h.

References incomingStreams_, incrementOutgoingStreams(), isDownstream(), maybeResumePausedPipelinedTransaction(), and uint32_t.

Referenced by detach(), maybeResumePausedPipelinedTransaction(), onEgressMessageFinished(), and onMessageBegin().

                                         {
     return isDownstream() ? incomingStreams_ : transactions_.size();
   }

void proxygen::HTTPSession::getReadBuffer	(	void **	bufReturn,
		size_t *	lenReturn
	)

overrideprotectedvirtual

When data becomes available, getReadBuffer() will be invoked to get the buffer into which data should be read.

This method allows the ReadCallback to delay buffer allocation until data becomes available. This allows applications to manage large numbers of idle connections, without having to maintain a separate read buffer for each idle connection.

It is possible that in some cases, getReadBuffer() may be called multiple times before readDataAvailable() is invoked. In this case, the data will be written to the buffer returned from the most recent call to readDataAvailable(). If the previous calls to readDataAvailable() returned different buffers, the ReadCallback is responsible for ensuring that they are not leaked.

If getReadBuffer() throws an exception, returns a nullptr buffer, or returns a 0 length, the ReadCallback will be uninstalled and its readError() method will be invoked.

getReadBuffer() is not allowed to change the transport state before it returns. (For example, it should never uninstall the read callback, or set a different read callback.)

Parameters

bufReturn	getReadBuffer() should update *bufReturn to contain the address of the read buffer. This parameter will never be nullptr.
lenReturn	getReadBuffer() should update *lenReturn to contain the maximum number of bytes that may be written to the read buffer. This parameter will never be nullptr.

Definition at line 526 of file HTTPSession.cpp.

References FOLLY_SCOPED_TRACE_SECTION, fizz::kMinReadSize, proxygen::HTTPSessionBase::maxReadBufferSize_, folly::IOBufQueue::preallocate(), and readBuf_.

Referenced by getHTTPPriority().

                                                       {
   FOLLY_SCOPED_TRACE_SECTION("HTTPSession - getReadBuffer");
   pair<void*,uint32_t> readSpace =
     readBuf_.preallocate(kMinReadSize, HTTPSessionBase::maxReadBufferSize_);
   *buf = readSpace.first;
   *bufSize = readSpace.second;
 }

SecondaryAuthManager * proxygen::HTTPSession::getSecondAuthManager ( ) const

Get the SecondaryAuthManager attached to this session.

Definition at line 1821 of file HTTPSession.cpp.

References secondAuthManager_.

Referenced by connCloseByRemote().

                                                               {
   return secondAuthManager_.get();
 }

std::string proxygen::HTTPSession::getSecurityProtocol ( ) const

inlineoverrideprotectedvirtual

Definition at line 358 of file HTTPSession.h.

References folly::pushmi::operators::error(), onAbort(), onBody(), onCertificate(), onCertificateRequest(), onChunkComplete(), onChunkHeader(), onError(), onExMessageBegin(), onGoaway(), onHeadersComplete(), onMessageBegin(), onMessageComplete(), onPingReply(), onPingRequest(), onPriority(), onPushMessageBegin(), onSettings(), onSettingsAck(), onTrailersComplete(), onWindowUpdate(), settings, sock_, uint16_t, uint32_t, and uint64_t.

                                                  {
     return sock_->getSecurityProtocol();
   }

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

inlineoverridevirtualnoexcept

Definition at line 130 of file HTTPSession.h.

References getCurrentTransportInfo(), proxygen::HTTPSessionBase::getSetupTransportInfo(), sendCertificateRequest(), sendPing(), sendPriority(), sendSettings(), setEgressBytesLimit(), setMaxConcurrentIncomingStreams(), startNow(), uint32_t, and uint64_t.

              {
     return HTTPSessionBase::getSetupTransportInfo();
   }

virtual HTTPTransaction::Handler* proxygen::HTTPSession::getTransactionTimeoutHandler ( HTTPTransaction * txn )

protectedpure virtual

Called by transactionTimeout if the transaction has no handler.

Implemented in proxygen::HTTPUpstreamSession, and proxygen::HTTPDownstreamSession.

Referenced by connCloseByRemote(), and transactionTimeout().

folly::AsyncTransportWrapper* proxygen::HTTPSession::getTransport ( )

inlineoverridevirtual

Implements proxygen::HTTPSessionBase.

Definition at line 61 of file HTTPSession.h.

References sock_.

Referenced by connCloseByRemote(), getCertAuthSettingVal(), onCertificate(), onCertificateRequest(), and verifyCertAuthSetting().

                                                       {
     return sock_.get();
   }

const folly::AsyncTransportWrapper* proxygen::HTTPSession::getTransport ( ) const

inlineoverridevirtual

Implements proxygen::HTTPSessionBase.

Definition at line 72 of file HTTPSession.h.

References sock_.

                                                                   {
     return sock_.get();
   }

HTTPSessionBase::SessionType proxygen::HTTPSession::getType ( ) const

inlineoverridevirtualnoexcept

Implements proxygen::HTTPSessionBase.

Definition at line 57 of file HTTPSession.h.

References proxygen::HTTPSessionBase::HTTP.

                                                                {
     return HTTPSessionBase::SessionType::HTTP;
   }

const folly::AsyncTransportWrapper* proxygen::HTTPSession::getUnderlyingTransport ( ) const

inlineoverrideprotectedvirtualnoexcept

Returns the underlying AsyncTransportWrapper. Overrides HTTPTransaction::Transport::getUnderlyingTransport().

Definition at line 446 of file HTTPSession.h.

References sock_.

                               {
     return sock_.get();
   }

bool proxygen::HTTPSession::hasActiveTransactions ( ) const

inlineoverridevirtual

Implements proxygen::HTTPSessionBase.

Definition at line 76 of file HTTPSession.h.

References transactions_.

                                               {
     return !transactions_.empty();
   }

bool proxygen::HTTPSession::hasMoreWrites ( ) const

protected

Check whether the session has any writes in progress or upcoming

Definition at line 2800 of file HTTPSession.cpp.

References proxygen::HTTP2PriorityQueue::empty(), folly::IOBufQueue::front(), numActiveWrites_, pendingWrites_, txnEgressQueue_, and writeBuf_.

Referenced by closeWhenIdle(), detach(), dropConnection(), proxygen::HTTPUpstreamSession::isReusable(), onWriteSuccess(), runLoopCallback(), sessionByteOffset(), and shutdownTransport().

                                  {
   VLOG(10) << __PRETTY_FUNCTION__
     << " numActiveWrites_: " << numActiveWrites_
     << " pendingWrites_.empty(): " << pendingWrites_.empty()
     << " pendingWrites_.size(): " << pendingWrites_.size()
     << " txnEgressQueue_.empty(): " << txnEgressQueue_.empty();
 
   return (numActiveWrites_ != 0) ||
     !pendingWrites_.empty() || writeBuf_.front() ||
     !txnEgressQueue_.empty();
 }

void proxygen::HTTPSession::immediateShutdown ( )

protected

Immediately shut down the session, by deleting the loop callbacks first

Definition at line 479 of file HTTPSession.cpp.

References folly::EventBase::LoopCallback::cancelLoopCallback(), checkForShutdown(), folly::EventBase::LoopCallback::isLoopCallbackScheduled(), shutdownTransportCb_, transactions_, and writesShutdown().

Referenced by dropConnection(), and sessionByteOffset().

                                     {
   if (isLoopCallbackScheduled()) {
     cancelLoopCallback();
   }
   if (shutdownTransportCb_) {
     shutdownTransportCb_.reset();
   }
   // checkForShutdown only closes the connection if these conditions are true
   DCHECK(writesShutdown());
   DCHECK(transactions_.empty());
   checkForShutdown();
 }

void proxygen::HTTPSession::incrementOutgoingStreams ( )

private

Definition at line 2625 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::onNewOutgoingStream(), and outgoingStreams_.

Referenced by createTransaction(), getPipelineStreamCount(), and sendHeaders().

                                       {
   outgoingStreams_++;
   HTTPSessionBase::onNewOutgoingStream(outgoingStreams_);
 }

void proxygen::HTTPSession::invalidStream	(	HTTPCodec::StreamID	stream,
		ErrorCode	code = `ErrorCode::_SPDY_INVALID_STREAM`
	)

private

Invoked when the codec processes callbacks for a stream we are no longer tracking.

Definition at line 2910 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::ERROR, proxygen::HTTPException::INGRESS_AND_EGRESS, onError(), proxygen::HTTPException::setCodecStatusCode(), and proxygen::HTTPCodec::supportsParallelRequests().

Referenced by getMaxConcurrentOutgoingStreamsRemote(), onBody(), onChunkComplete(), onChunkHeader(), onError(), onExMessageBegin(), onHeadersComplete(), onMessageComplete(), onPushMessageBegin(), and onTrailersComplete().

                                                                         {
   if (!codec_->supportsParallelRequests()) {
     LOG(ERROR) << "Invalid stream on non-parallel codec.";
     return;
   }
 
   HTTPException err(HTTPException::Direction::INGRESS_AND_EGRESS,
                     folly::to<std::string>("invalid stream=", stream));
   // TODO: Below line will change for HTTP/2 -- just call a const getter
   // function for the status code.
   err.setCodecStatusCode(code);
   onError(stream, err, true);
 }

template<typename... Args1, typename... Args2>

void proxygen::HTTPSession::invokeOnAllTransactions	(	void(HTTPTransaction::*)(Args1...)	fn,
		Args2 &&...	args
	)

inlineprotected

This function invokes a callback on all transactions. It is safe, but runs in O(n*log n) and if the callback adds transactions, they will not get the callback.

Definition at line 584 of file HTTPSession.h.

References drainImpl(), errorOnAllTransactions(), errorOnTransactionId(), errorOnTransactionIds(), findTransaction(), g(), pauseReadsImpl(), resumeReadsImpl(), resumeTransactions(), shouldShutdown(), string, and transactions_.

Referenced by onGoaway(), onSetSendWindow(), resumeTransactions(), runLoopCallback(), shutdownTransport(), and updateWriteBufSize().

                                                 {
     DestructorGuard g(this);
     std::vector<HTTPCodec::StreamID> ids;
     for (const auto& txn: transactions_) {
       ids.push_back(txn.first);
     }
     for (auto idit = ids.begin(); idit != ids.end() && !transactions_.empty();
          ++idit) {
       auto txn = findTransaction(*idit);
       if (txn != nullptr) {
         (txn->*fn)(std::forward<Args2>(args)...);
       }
     }
   }

bool proxygen::HTTPSession::isBufferMovable ( )

overrideprotectedvirtualnoexcept

When data becomes available, isBufferMovable() will be invoked to figure out which API will be used, readBufferAvailable() or readDataAvailable(). If isBufferMovable() returns true, that means ReadCallback supports the IOBuf ownership transfer and readBufferAvailable() will be used. Otherwise, not.

By default, isBufferMovable() always return false. If readBufferAvailable() is implemented and to be invoked, You should overwrite isBufferMovable() and return true in the inherited class.

This method allows the AsyncSocket/AsyncSSLSocket do buffer allocation by itself until data becomes available. Compared with the pre/post buffer allocation in getReadBuffer()/readDataAvailabe(), readBufferAvailable() has two advantages. First, this can avoid memcpy. E.g., in AsyncSSLSocket, the decrypted data was copied from the openssl internal buffer to the readbuf buffer. With the buffer ownership transfer, the internal buffer can be directly "moved" to ReadCallback. Second, the memory allocation can be more precise. The reason is AsyncSocket/AsyncSSLSocket can allocate the memory of precise size because they have more context about the available data than ReadCallback. Think about the getReadBuffer() pre-allocate 4072 bytes buffer, but the available data is always 16KB (max OpenSSL record size).

Reimplemented from folly::AsyncReader::ReadCallback.

Definition at line 552 of file HTTPSession.cpp.

Referenced by getHTTPPriority().

                                       {
   return true;
 }

bool proxygen::HTTPSession::isBusy ( ) const

overridevirtual

Check whether the connection has any requests outstanding.

Implements wangle::ManagedConnection.

Definition at line 448 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::isBusy(), and transactions_.

Referenced by closeWhenIdle(), and timeoutExpired().

                           {
   return !transactions_.empty() || codec_->isBusy();
 }

bool proxygen::HTTPSession::isConnWindowFull ( ) const

inlineprivate

Definition at line 765 of file HTTPSession.h.

References commonEom(), connFlowControl_, proxygen::FlowControlFilter::getAvailableSend(), int64_t, folly::pushmi::__adl::noexcept(), onDeleteAckEvent(), onLastByteEvent(), onPingReplyLatency(), and uint64_t.

Referenced by getNextToSend().

                                 {
     return connFlowControl_ && connFlowControl_->getAvailableSend() == 0;
   }

bool proxygen::HTTPSession::isDownstream ( ) const

private

Definition at line 521 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::DOWNSTREAM, and proxygen::HTTPCodec::getTransportDirection().

Referenced by createTransaction(), decrementTransactionCount(), describe(), getMaxConcurrentOutgoingStreamsRemote(), getPipelineStreamCount(), newPushedTransaction(), onAbort(), onMessageBegin(), onPushMessageBegin(), proxygen::HTTPSession::ShutdownTransportCallback::runLoopCallback(), sendHeaders(), and setupCodec().

                                      {
   return codec_->getTransportDirection() == TransportDirection::DOWNSTREAM;
 }

bool proxygen::HTTPSession::isDraining ( ) const

inlineoverrideprotectedvirtual

Returns true if this session is draining. This can happen if drain() is called explicitly, if a GOAWAY frame is received, or during shutdown.

proxygen::HTTPSession::draining_

Definition at line 455 of file HTTPSession.h.

References drain(), draining_, int64_t, runLoopCallback(), scheduleWrite(), shutdownTransport(), shutdownTransportWithReset(), string, updateWriteBufSize(), and updateWriteCount().

455 { return draining_; }

bool draining_

Definition: HTTPSession.h:711

bool proxygen::HTTPSession::isUpstream ( ) const

private

Definition at line 517 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::getTransportDirection(), and proxygen::UPSTREAM.

Referenced by createTransaction(), decrementTransactionCount(), drain(), getCertAuthSettingVal(), getMaxConcurrentOutgoingStreamsRemote(), onCertificate(), onCertificateRequest(), onGoaway(), sendHeaders(), shouldShutdown(), and verifyCertAuthSetting().

                                    {
   return codec_->getTransportDirection() == TransportDirection::UPSTREAM;
 }

bool proxygen::HTTPSession::maybeResumePausedPipelinedTransaction	(	size_t	oldStreamCount,
		uint32_t	txnSeqn
	)

private

Definition at line 1879 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, getPipelineStreamCount(), proxygen::HTTPCodec::supportsParallelRequests(), and transactions_.

Referenced by detach(), getPipelineStreamCount(), and onEgressMessageFinished().

                                            {
   if (!codec_->supportsParallelRequests() && !transactions_.empty() &&
       getPipelineStreamCount() < oldStreamCount &&
       getPipelineStreamCount() == 1) {
     auto& nextTxn = transactions_.rbegin()->second;
     DCHECK_EQ(nextTxn.getSequenceNumber(), txnSeqn + 1);
     DCHECK(!nextTxn.isIngressComplete());
     DCHECK(nextTxn.isIngressPaused());
     VLOG(4) << "Resuming paused pipelined txn " << nextTxn;
     nextTxn.resumeIngress();
     return true;
   }
   return false;
 }

bool proxygen::HTTPSession::needToBlockForReplaySafety ( ) const

inlineoverrideprivatevirtual

This is a temporary workaround until we have a better way to allocate stream IDs to waiting transactions.

Definition at line 822 of file HTTPSession.h.

References onReplaySafe(), and waitingForReplaySafety_.

                                                    {
     return !waitingForReplaySafety_.empty();
   }

HTTPTransaction *FOLLY_NULLABLE proxygen::HTTPSession::newExTransaction	(	HTTPTransaction::Handler *	handler,
		HTTPCodec::StreamID	controlStream,
		bool	unidirectional = `false`
	)

overrideprotectedvirtualnoexcept

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::createStream(), createTransaction(), draining_, proxygen::ENABLE_EX_HEADERS, proxygen::ERROR, proxygen::getCodecProtocolString(), proxygen::HTTPCodec::getEgressSettings(), proxygen::HTTPTransaction::getID(), proxygen::HTTPCodec::getProtocol(), handler(), maxConcurrentOutgoingStreamsRemote_, proxygen::HTTPCodec::NoStream, outgoingStreams_, proxygen::HTTPTransaction::setHandler(), setNewTransactionPauseState(), and started_.

Definition at line 681 of file HTTPSession.cpp.

Referenced by numIncomingStreams().

                                   {
   CHECK(handler && controlStream > 0);
   auto eSettings = codec_->getEgressSettings();
   if (!eSettings || !eSettings->getSetting(SettingsId::ENABLE_EX_HEADERS, 0)) {
     LOG(ERROR) << getCodecProtocolString(codec_->getProtocol())
                << " does not support ExTransaction";
     return nullptr;
   }
   if (draining_ || (outgoingStreams_ >= maxConcurrentOutgoingStreamsRemote_)) {
     LOG(ERROR) << "cannot support any more transactions in " << *this;
     return nullptr;
   }
 
   DCHECK(started_);
   HTTPTransaction* txn =
     createTransaction(codec_->createStream(),
                       HTTPCodec::NoStream,
                       HTTPCodec::ExAttributes(controlStream, unidirectional));
   if (!txn) {
     return nullptr;
   }
 
   DestructorGuard dg(this);
   txn->setHandler(handler);
   setNewTransactionPauseState(txn->getID());
   return txn;
 }

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

overrideprotectedvirtualnoexcept

Definition at line 649 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::createStream(), createTransaction(), draining_, FOLLY_NULLABLE, proxygen::HTTPTransaction::getID(), handler(), isDownstream(), maxConcurrentOutgoingStreamsRemote_, proxygen::HTTPCodec::NoExAttributes, outgoingStreams_, proxygen::HTTPTransaction::setHandler(), setNewTransactionPauseState(), and proxygen::HTTPCodec::supportsPushTransactions().

Referenced by numIncomingStreams().

                                                 {
   if (!codec_->supportsPushTransactions()) {
     return nullptr;
   }
   CHECK(isDownstream());
   CHECK_NOTNULL(handler);
   if (draining_ || (outgoingStreams_ >= maxConcurrentOutgoingStreamsRemote_)) {
     // This session doesn't support any more push transactions
     // This could be an actual problem - since a single downstream SPDY session
     // might be connected to N upstream hosts, each of which send M pushes,
     // which exceeds the limit.
     // should we queue?
     return nullptr;
   }
 
   HTTPTransaction* txn = createTransaction(codec_->createStream(),
                                            assocStreamId,
                                            HTTPCodec::NoExAttributes);
   if (!txn) {
     return nullptr;
   }
 
   DestructorGuard dg(this);
   auto txnID = txn->getID();
   txn->setHandler(handler);
   setNewTransactionPauseState(txnID);
   return txn;
 }

void proxygen::HTTPSession::notifyEgressBodyBuffered ( int64_t bytes )

overrideprotectedvirtualnoexcept

Definition at line 1997 of file HTTPSession.cpp.

References folly::EventBase::LoopCallback::isLoopCallbackScheduled(), pendingWriteSizeDelta_, sock_, and updateWriteBufSize().

Referenced by numIncomingStreams().

                                                             {
   pendingWriteSizeDelta_ += bytes;
   // any net change requires us to update pause/resume state in the
   // loop callback
   if (pendingWriteSizeDelta_ > 0) {
     // pause inline, resume in loop
     updateWriteBufSize(0);
   } else if (!isLoopCallbackScheduled()) {
     sock_->getEventBase()->runInLoop(this);
   }
 }

void proxygen::HTTPSession::notifyIngressBodyProcessed ( uint32_t bytes )

overrideprotectedvirtualnoexcept

Definition at line 1986 of file HTTPSession.cpp.

References connFlowControl_, proxygen::FlowControlFilter::ingressBytesProcessed(), proxygen::HTTPSessionBase::notifyBodyProcessed(), resumeReads(), scheduleWrite(), and writeBuf_.

Referenced by numIncomingStreams().

                                                                {
   if (HTTPSessionBase::notifyBodyProcessed(bytes)) {
     resumeReads();
   }
   if (connFlowControl_ &&
       connFlowControl_->ingressBytesProcessed(writeBuf_, bytes)) {
     scheduleWrite();
   }
 }

void proxygen::HTTPSession::notifyPendingEgress ( )

overrideprotectedvirtualnoexcept

References proxygen::CANCEL, findTransaction(), proxygen::HTTPTransaction::getAssocTxnId(), proxygen::getErrorCodeString(), proxygen::HTTPTransaction::getExTransactions(), proxygen::HTTPTransaction::getPushedTransactions(), proxygen::HTTPException::INGRESS_AND_EGRESS, isDownstream(), proxygen::kErrorStreamAbort, proxygen::HTTPTransaction::onError(), proxygen::HTTPException::setCodecStatusCode(), proxygen::Exception::setProxygenError(), and streamID.

Definition at line 453 of file HTTPSession.cpp.

References scheduleWrite().

Referenced by numIncomingStreams().

                                           {
   scheduleWrite();
 }

void proxygen::HTTPSession::notifyPendingShutdown ( )

overridevirtual

Notify the connection that a shutdown is pending. This method will be called at the beginning of graceful shutdown.

Implements wangle::ManagedConnection.

Definition at line 458 of file HTTPSession.cpp.

References drain().

Referenced by readTimeoutExpired(), and timeoutExpired().

                                    {
   VLOG(4) << *this << " notified pending shutdown";
   drain();
 }

uint32_t proxygen::HTTPSession::numIncomingStreams ( ) const

inlineoverrideprotectedvirtual

Return the number of open streams started by the remote side. Parallel codecs with a maximum number of streams will invoke this to determine if a new stream exceeds the limit.

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 401 of file HTTPSession.h.

References detach(), handler(), incomingStreams_, int64_t, newExTransaction(), newPushedTransaction(), notifyEgressBodyBuffered(), notifyIngressBodyProcessed(), notifyPendingEgress(), pauseIngress(), resumeIngress(), sendAbort(), sendBody(), sendChunkHeader(), sendChunkTerminator(), sendEOM(), sendHeaders(), sendPriority(), sendWindowUpdate(), folly::size(), statusCode, transactionTimeout(), and uint32_t.

                                                {
     return incomingStreams_;
   }

uint32_t proxygen::HTTPSession::numOutgoingStreams ( ) const

inlineoverrideprotectedvirtual

Return the number of open streams started by this codec callback. Parallel codecs with a maximum number of streams will invoke this to determine if a new stream exceeds the limit.

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 398 of file HTTPSession.h.

References outgoingStreams_.

                                                {
     return outgoingStreams_;
   }

void proxygen::HTTPSession::onAbort	(	HTTPCodec::StreamID	,
		ErrorCode
	)

overrideprotectedvirtual

Called when the peer has asked to shut down a stream immediately.

Parameters

stream	The stream ID
code	The code the stream was aborted with

Note: Not applicable to all protocols.

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 1163 of file HTTPSession.cpp.

Referenced by getSecurityProtocol().

                                           {
   VLOG(4) << "stream abort on " << *this << ", streamID=" << streamID
           << ", code=" << getErrorCodeString(code);
   HTTPTransaction* txn = findTransaction(streamID);
   if (!txn) {
     VLOG(4) << *this << " abort for unrecognized transaction, streamID= "
       << streamID;
     return;
   }
   HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS,
     folly::to<std::string>("Stream aborted, streamID=",
       streamID, ", code=", getErrorCodeString(code)));
   ex.setProxygenError(kErrorStreamAbort);
   ex.setCodecStatusCode(code);
   DestructorGuard dg(this);
   if (isDownstream() && !txn->getAssocTxnId() && code == ErrorCode::CANCEL) {
     // Cancelling the assoc txn cancels all push txns
     for (auto it = txn->getPushedTransactions().begin();
          it != txn->getPushedTransactions().end(); ) {
       auto pushTxn = findTransaction(*it);
       ++it;
       DCHECK(pushTxn != nullptr);
       pushTxn->onError(ex);
     }
   }
   auto exTxns = txn->getExTransactions();
   for (auto it = exTxns.begin(); it != exTxns.end(); ++it) {
     auto exTxn = findTransaction(*it);
     if (exTxn) {
       exTxn->onError(ex);
     }
   }
   txn->onError(ex);
 }

void proxygen::HTTPSession::onBody	(	HTTPCodec::StreamID	stream,
		std::unique_ptr< folly::IOBuf >	chain,
		uint16_t	padding
	)

overrideprotectedvirtual

Called for each block of message body data

Parameters

stream	The stream ID
chain	One or more buffers of body data. The codec will remove any protocol framing, such as HTTP/1.1 chunk headers, from the buffers before calling this function.
padding	Number of pad bytes that came with the data segment

References proxygen::HTTP2PriorityQueue::empty(), flowControlTimeout_, proxygen::HTTPSession::FlowControlTimeout::getTimeoutDuration(), proxygen::HTTPSessionBase::infoCallback_, folly::HHWheelTimer::Callback::isScheduled(), proxygen::HTTPSessionBase::InfoCallback::onFlowControlWindowClosed(), proxygen::HTTPSessionStats::recordSessionStalled(), proxygen::WheelTimerInstance::scheduleTimeout(), proxygen::HTTPSessionBase::sessionStats_, timeout_, and txnEgressQueue_.

Definition at line 970 of file HTTPSession.cpp.

References folly::IOBuf::computeChainDataLength(), connFlowControl_, findTransaction(), FOLLY_SCOPED_TRACE_SECTION, proxygen::FlowControlFilter::ingressBytesProcessed(), invalidStream(), folly::gen::move, proxygen::HTTPSessionBase::onBodyImpl(), pauseReads(), scheduleWrite(), uint64_t, and writeBuf_.

Referenced by getSecurityProtocol().

                                                                {
   FOLLY_SCOPED_TRACE_SECTION("HTTPSession - onBody");
   DestructorGuard dg(this);
   // The codec's parser detected part of the ingress message's
   // entity-body.
   uint64_t length = chain->computeChainDataLength();
   HTTPTransaction* txn = findTransaction(streamID);
   if (!txn) {
     if (connFlowControl_ &&
         connFlowControl_->ingressBytesProcessed(writeBuf_, length)) {
       scheduleWrite();
     }
     invalidStream(streamID);
     return;
   }
 
   if (HTTPSessionBase::onBodyImpl(std::move(chain), length, padding, txn)) {
     VLOG(4) << *this << " pausing due to read limit exceeded.";
     pauseReads();
   }
 }

void proxygen::HTTPSession::onCertificate	(	uint16_t	,
		std::unique_ptr< folly::IOBuf >
	)

overrideprotectedvirtual

Called upon receipt of an authenticator, for protocols that support secondary certificate authentication.

Parameters

certId	The Cert-ID identifying this authenticator
authenticator	The authenticator request

Note: Not all protocols support secondary certificate authentication. HTTP/2 does, but HTTP/1.1 doesn't.

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 1380 of file HTTPSession.cpp.

References proxygen::DOWNSTREAM, getTransport(), folly::AsyncTransportWrapper::getUnderlyingTransport(), isUpstream(), folly::gen::move, secondAuthManager_, and proxygen::UPSTREAM.

Referenced by getSecurityProtocol().

                                                                     {
   DestructorGuard dg(this);
   VLOG(4) << "CERTIFICATE on" << *this << ", certId=" << certId;
 
   bool isValid = false;
   auto fizzBase = getTransport()->getUnderlyingTransport<AsyncFizzBase>();
   if (fizzBase) {
     if (isUpstream()) {
       isValid = secondAuthManager_->validateAuthenticator(
           *fizzBase,
           TransportDirection::UPSTREAM,
           certId,
           std::move(authenticator));
     } else {
       isValid = secondAuthManager_->validateAuthenticator(
           *fizzBase,
           TransportDirection::DOWNSTREAM,
           certId,
           std::move(authenticator));
     }
   } else {
     VLOG(4) << "Underlying transport does not support secondary "
                "authentication.";
     return;
   }
   if (isValid) {
     VLOG(4) << "Successfully validated the authenticator provided by the peer.";
   } else {
     VLOG(4) << "Failed to validate the authenticator provided by the peer";
   }
 }

void proxygen::HTTPSession::onCertificateRequest	(	uint16_t	,
		std::unique_ptr< folly::IOBuf >
	)

overrideprotectedvirtual

Called upon receipt of a certificate request frame, for protocols that support secondary certificate authentication.

Parameters

requestId	The Request-ID identifying the certificate request
authRequest	The authenticator request

Note: Not all protocols support secondary certificate authentication. HTTP/2 does, but HTTP/1.1 doesn't.

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 1347 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::DOWNSTREAM, proxygen::HTTPCodec::generateCertificate(), getTransport(), folly::AsyncTransportWrapper::getUnderlyingTransport(), isUpstream(), folly::gen::move, scheduleWrite(), secondAuthManager_, proxygen::UPSTREAM, and writeBuf_.

Referenced by getSecurityProtocol().

                                                                          {
   DestructorGuard dg(this);
   VLOG(4) << "CERTIFICATE_REQUEST on" << *this << ", requestId=" << requestId;
 
   std::pair<uint16_t, std::unique_ptr<folly::IOBuf>> authenticator;
   auto fizzBase = getTransport()->getUnderlyingTransport<AsyncFizzBase>();
   if (fizzBase) {
     if (isUpstream()) {
       authenticator =
           secondAuthManager_->getAuthenticator(*fizzBase,
                                                TransportDirection::UPSTREAM,
                                                requestId,
                                                std::move(authRequest));
     } else {
       authenticator =
           secondAuthManager_->getAuthenticator(*fizzBase,
                                                TransportDirection::DOWNSTREAM,
                                                requestId,
                                                std::move(authRequest));
     }
   } else {
     VLOG(4) << "Underlying transport does not support secondary "
                "authentication.";
     return;
   }
   if (codec_->generateCertificate(writeBuf_,
                                   authenticator.first,
                                   std::move(authenticator.second)) > 0) {
     scheduleWrite();
   }
 }

void proxygen::HTTPSession::onChunkComplete ( HTTPCodec::StreamID )

overrideprotectedvirtual

Called when the terminating CRLF is received to end a chunk of HTTP body data.

Parameters

stream The stream ID

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 1018 of file HTTPSession.cpp.

References findTransaction(), invalidStream(), and proxygen::HTTPTransaction::onIngressChunkComplete().

Referenced by getSecurityProtocol().

                                                             {
   // The codec's parser detected the end of the message body chunk
   // associated with the most recent call to onChunkHeader().
   HTTPTransaction* txn = findTransaction(streamID);
   if (!txn) {
     invalidStream(streamID);
     return;
   }
   txn->onIngressChunkComplete();
 }

void proxygen::HTTPSession::onChunkHeader	(	HTTPCodec::StreamID	,
		size_t
	)

overrideprotectedvirtual

Called for each HTTP chunk header.

onChunkHeader() will be called when the chunk header is received. As the chunk data arrives, it will be passed to the callback normally with onBody() calls. Note that the chunk data may arrive in multiple onBody() calls: it is not guaranteed to arrive in a single onBody() call.

After the chunk data has been received and the terminating CRLF has been received, onChunkComplete() will be called.

Parameters

stream	The stream ID
length	The chunk length.

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 993 of file HTTPSession.cpp.

References findTransaction(), invalidStream(), and proxygen::HTTPTransaction::onIngressChunkHeader().

Referenced by getSecurityProtocol().

                                                {
   // The codec's parser detected a chunk header (meaning that this
   // connection probably is HTTP/1.1).
   //
   // After calling onChunkHeader(), the codec will call onBody() zero
   // or more times and then call onChunkComplete().
   //
   // The reason for this callback on the chunk header is to support
   // an optimization.  In general, the job of the codec is to present
   // the HTTPSession with an abstract view of a message,
   // with all the details of wire formatting hidden.  However, there's
   // one important case where we want to know about chunking: reverse
   // proxying where both the client and server streams are HTTP/1.1.
   // In that scenario, we preserve the server's chunk boundaries when
   // sending the response to the client, in order to avoid possibly
   // making the egress packetization worse by rechunking.
   HTTPTransaction* txn = findTransaction(streamID);
   if (!txn) {
     invalidStream(streamID);
     return;
   }
   txn->onIngressChunkHeader(length);
 }

void proxygen::HTTPSession::onConnectionSendWindowClosed ( )

overrideprivatevirtual

Implements proxygen::FlowControlFilter::Callback.

Definition at line 2880 of file HTTPSession.cpp.

Referenced by getMaxConcurrentOutgoingStreamsRemote().

                                                {
   if(!txnEgressQueue_.empty()) {
     VLOG(4) << *this << " session stalled by flow control";
     if (sessionStats_) {
       sessionStats_->recordSessionStalled();
     }
   }
   DCHECK(!flowControlTimeout_.isScheduled());
   if (infoCallback_) {
     infoCallback_->onFlowControlWindowClosed(*this);
   }
   auto timeout = flowControlTimeout_.getTimeoutDuration();
   if (timeout != std::chrono::milliseconds(0)) {
     timeout_.scheduleTimeout(&flowControlTimeout_, timeout);
   } else {
     timeout_.scheduleTimeout(&flowControlTimeout_);
   }
 }

void proxygen::HTTPSession::onConnectionSendWindowOpen ( )

overrideprivatevirtual

Callback function from the flow control filter if the full window becomes not full.

Implements proxygen::FlowControlFilter::Callback.

Definition at line 2874 of file HTTPSession.cpp.

References folly::HHWheelTimer::Callback::cancelTimeout(), flowControlTimeout_, and scheduleWrite().

Referenced by getMaxConcurrentOutgoingStreamsRemote().

                                              {
   flowControlTimeout_.cancelTimeout();
   // We can write more now. Schedule a write.
   scheduleWrite();
 }

void proxygen::HTTPSession::onDeleteAckEvent ( )

overrideprivatevirtualnoexcept

Implements proxygen::ByteEventTracker::Callback.

Definition at line 2930 of file HTTPSession.cpp.

References readsShutdown(), shutdownTransport(), and transactions_.

Referenced by isConnWindowFull().

                                             {
   if (readsShutdown()) {
     shutdownTransport(true, transactions_.empty());
   }
 }

void proxygen::HTTPSession::onEgressBufferCleared ( )

overrideprivatevirtual

Implements folly::AsyncTransport::BufferCallback.

Definition at line 2942 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::infoCallback_, and proxygen::HTTPSessionBase::InfoCallback::onEgressBufferCleared().

Referenced by getMaxConcurrentOutgoingStreamsRemote().

                                         {
   if (infoCallback_) {
     infoCallback_->onEgressBufferCleared(*this);
   }
 }

void proxygen::HTTPSession::onEgressBuffered ( )

overrideprivatevirtual

Implements folly::AsyncTransport::BufferCallback.

Definition at line 2936 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::infoCallback_, and proxygen::HTTPSessionBase::InfoCallback::onEgressBuffered().

Referenced by getMaxConcurrentOutgoingStreamsRemote().

                                    {
   if (infoCallback_) {
     infoCallback_->onEgressBuffered(*this);
   }
 }

void proxygen::HTTPSession::onEgressMessageFinished	(	HTTPTransaction *	txn,
		bool	withRST = `false`
	)

protected

Invoked when the transaction finishes sending a message and appropriately shuts down reads and/or writes with respect to downstream or upstream semantics.

Definition at line 1714 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, decrementTransactionCount(), proxygen::HTTPTransaction::getMaxDeferredSize(), getPipelineStreamCount(), proxygen::HTTPTransaction::getSequenceNumber(), proxygen::HTTPSessionBase::infoCallback_, proxygen::HTTPCodec::isReusable(), maybeResumePausedPipelinedTransaction(), proxygen::HTTPSessionBase::InfoCallback::onRequestEnd(), readsShutdown(), resetAfterDrainingWrites_, proxygen::HTTPSessionBase::setCloseReason(), shutdownTransport(), shutdownTransportCb_, sock_, proxygen::TRANSACTION_ABORT, and transactions_.

Referenced by commonEom(), onHeadersSent(), and sendAbort().

                                                                        {
   // If the semantics of the protocol don't permit more messages
   // to be read or sent on this connection, close the socket in one or
   // more directions.
   CHECK(!transactions_.empty());
 
   if (infoCallback_) {
     infoCallback_->onRequestEnd(*this, txn->getMaxDeferredSize());
   }
   auto oldStreamCount = getPipelineStreamCount();
   decrementTransactionCount(txn, false, true);
   if (withRST || ((!codec_->isReusable() || readsShutdown()) &&
                   transactions_.size() == 1)) {
     // We should shutdown reads if we are closing with RST or we aren't
     // interested in any further messages (ie if we are a downstream session).
     // Upgraded sessions have independent ingress and egress, and the reads
     // need not be shutdown on egress finish.
     if (withRST) {
       // Let any queued writes complete, but send a RST when done.
       VLOG(4) << *this << " resetting egress after this message";
       resetAfterDrainingWrites_ = true;
       setCloseReason(ConnectionCloseReason::TRANSACTION_ABORT);
       shutdownTransport(true, true);
     } else {
       // the reason is already set (either not reusable or readshutdown).
 
       // Defer normal shutdowns until the end of the loop.  This
       // handles an edge case with direct responses with Connection:
       // close served before ingress EOM.  The remainder of the ingress
       // message may be in the parse loop, so give it a chance to
       // finish out and avoid a kErrorEOF
 
       // we can get here during shutdown, in that case do not schedule a
       // shutdown callback again
       if (!shutdownTransportCb_) {
         // Just for safety, the following bumps the refcount on this session
         // to keep it live until the loopCb runs
         shutdownTransportCb_.reset(new ShutdownTransportCallback(this));
         sock_->getEventBase()->runInLoop(shutdownTransportCb_.get(), true);
       }
     }
   } else {
     maybeResumePausedPipelinedTransaction(oldStreamCount,
                                           txn->getSequenceNumber());
   }
 }

void proxygen::HTTPSession::onError	(	HTTPCodec::StreamID	stream,
		const HTTPException &	error,
		bool	newTxn
	)

overrideprotectedvirtual

Called when a parsing or protocol error has occurred

Parameters

stream	The stream ID
error	Description of the error
newTxn	true if onMessageBegin has not been called for txn

References proxygen::HTTPSessionBase::codec_, createTransaction(), folly::pushmi::operators::error(), findTransaction(), proxygen::HTTPTransaction::getEgressState(), proxygen::HTTPTransaction::getHandler(), proxygen::HTTPSessionBase::handleErrorDirectly(), proxygen::HTTPSessionBase::infoCallback_, ingressError_, invalidStream(), proxygen::HTTPCodec::isReusable(), proxygen::kErrorMessage, proxygen::HTTPCodec::NoExAttributes, proxygen::HTTPCodec::NoStream, proxygen::HTTPTransaction::onError(), proxygen::HTTPSessionBase::InfoCallback::onIngressError(), onNewTransactionParseError(), proxygen::HTTPSessionBase::InfoCallback::onRequestBegin(), onSessionParseError(), proxygen::SESSION_PARSE_ERROR, proxygen::HTTPSessionBase::setCloseReason(), shutdownTransport(), proxygen::HTTPCodec::supportsParallelRequests(), and transactions_.

Definition at line 1099 of file HTTPSession.cpp.

Referenced by getSecurityProtocol(), invalidStream(), onHeadersComplete(), and onPushMessageBegin().

                                                                    {
   DestructorGuard dg(this);
   // The codec detected an error in the ingress stream, possibly bad
   // syntax, a truncated message, or bad semantics in the frame.  If reads
   // are paused, queue up the event; otherwise, process it now.
   VLOG(4) << "Error on " << *this << ", streamID=" << streamID
           << ", " << error;
 
   if (ingressError_) {
     return;
   }
   if (!codec_->supportsParallelRequests()) {
     // this error should only prevent us from reading/handling more errors
     // on serial streams
     ingressError_ = true;
     setCloseReason(ConnectionCloseReason::SESSION_PARSE_ERROR);
   }
   if ((streamID == 0) && infoCallback_) {
     infoCallback_->onIngressError(*this, kErrorMessage);
   }
 
   if (!streamID) {
     ingressError_ = true;
     onSessionParseError(error);
     return;
   }
 
   HTTPTransaction* txn = findTransaction(streamID);
   if (!txn) {
     if (error.hasHttpStatusCode() && streamID != 0) {
       // If the error has an HTTP code, then parsing was fine, it just was
       // illegal in a higher level way
       txn = createTransaction(streamID, HTTPCodec::NoStream,
                               HTTPCodec::NoExAttributes);
       if (infoCallback_) {
         infoCallback_->onRequestBegin(*this);
       }
       if (txn) {
         handleErrorDirectly(txn, error);
       }
     } else if (newTxn) {
       onNewTransactionParseError(streamID, error);
     } else {
       VLOG(4) << *this << " parse error with invalid transaction";
       invalidStream(streamID);
     }
     return;
   }
 
   if (!txn->getHandler() &&
       txn->getEgressState() == HTTPTransactionEgressSM::State::Start) {
     handleErrorDirectly(txn, error);
     return;
   }
 
   txn->onError(error);
   if (!codec_->isReusable() && transactions_.empty()) {
     VLOG(4) << *this << "shutdown from onError";
     setCloseReason(ConnectionCloseReason::SESSION_PARSE_ERROR);
     shutdownTransport(true, true);
   }
 }

void proxygen::HTTPSession::onExMessageBegin	(	HTTPCodec::StreamID	,
		HTTPCodec::StreamID	,
		bool	,
		HTTPMessage *
	)

overrideprotectedvirtual

Called when a new extended message is seen while parsing the ingress.

Parameters

stream	The stream ID
controlStream	The stream ID of the associated stream, which can never be 0
msg	A newly allocated HTTPMessage

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 860 of file HTTPSession.cpp.

References createTransaction(), proxygen::ERROR, findTransaction(), getMessagePriority(), proxygen::HTTPSessionBase::infoCallback_, invalidStream(), proxygen::HTTPTransaction::isIngressPaused(), proxygen::HTTPCodec::NoStream, proxygen::HTTPSessionBase::InfoCallback::onRequestBegin(), and proxygen::PROTOCOL_ERROR.

Referenced by getSecurityProtocol().

                                                 {
   VLOG(4) << "processing new ExMessage=" << streamID
           << " on controlStream=" << controlStream << ", " << *this;
   if (infoCallback_) {
     infoCallback_->onRequestBegin(*this);
   }
   if (controlStream == 0) {
     LOG(ERROR) << "ExMessage=" << streamID << " should have an active control "
                << "stream=" << controlStream << ", " << *this;
     invalidStream(streamID, ErrorCode::PROTOCOL_ERROR);
     return;
   }
 
   HTTPTransaction* controlTxn = findTransaction(controlStream);
   if (!controlTxn) {
     // control stream is broken, or remote sends a bogus stream id
     LOG(ERROR) << "no control stream=" << controlStream << ", " << *this;
     return;
   }
 
   http2::PriorityUpdate messagePriority = getMessagePriority(msg);
   auto txn = createTransaction(streamID,
                                HTTPCodec::NoStream,
                                HTTPCodec::ExAttributes(controlStream,
                                                        unidirectional),
                                messagePriority);
   if (!txn) {
     return;  // This could happen if the socket is bad.
   }
   // control stream may be paused if the upstream is not ready yet
   if (controlTxn->isIngressPaused()) {
     txn->pauseIngress();
   }
 }

void proxygen::HTTPSession::onGoaway	(	uint64_t	,
		ErrorCode	,
		std::unique_ptr< folly::IOBuf >	= `nullptr`
	)

overrideprotectedvirtual

Called upon receipt of a goaway.

Parameters

lastGoodStreamID	Last successful stream created by the receiver
code	The code the connection was aborted with
debugData	The additional debug data for diagnostic purpose

Note: Not all protocols have goaways. SPDY does, but HTTP/1.1 doesn't.

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 1199 of file HTTPSession.cpp.

References folly::IOBuf::data(), drain(), errorOnTransactionId(), errorOnTransactionIds(), g(), proxygen::getErrorCodeString(), proxygen::getErrorString(), proxygen::GOAWAY, proxygen::HTTPException::INGRESS_AND_EGRESS, invokeOnAllTransactions(), isUpstream(), proxygen::kErrorStreamUnacknowledged, folly::gen::move, proxygen::NO_ERROR, proxygen::HTTPCodec::NoStream, proxygen::HTTPTransaction::onGoaway(), proxygen::HTTPSessionBase::setCloseReason(), proxygen::Exception::setProxygenError(), streamID, and transactions_.

Referenced by getSecurityProtocol().

                                                                 {
   DestructorGuard g(this);
   VLOG(4) << "GOAWAY on " << *this << ", code=" << getErrorCodeString(code);
 
   setCloseReason(ConnectionCloseReason::GOAWAY);
 
   // Drain active transactions and prevent new transactions
   drain();
 
   // We give the less-forceful onGoaway() first so that transactions have
   // a chance to do stat tracking before potentially getting a forceful
   // onError().
   invokeOnAllTransactions(&HTTPTransaction::onGoaway, code);
 
   // Abort transactions which have been initiated but not created
   // successfully at the remote end. Upstream transactions are created
   // with odd transaction IDs and downstream transactions with even IDs.
   vector<HTTPCodec::StreamID> ids;
   auto firstStream = HTTPCodec::NoStream;
 
   for (const auto& txn: transactions_) {
     auto streamID = txn.first;
     if (((bool)(streamID & 0x01) == isUpstream()) &&
         (streamID > lastGoodStreamID)) {
       if (firstStream == HTTPCodec::NoStream) {
         // transactions_ is a set so it should be sorted by stream id.
         // We will defer adding the firstStream to the id list until
         // we can determine whether we have a codec error code.
         firstStream = streamID;
         continue;
       }
 
       ids.push_back(streamID);
     }
   }
 
 
   if (firstStream != HTTPCodec::NoStream && code != ErrorCode::NO_ERROR) {
     // If we get a codec error, we will attempt to blame the first stream
     // by delivering a specific error to it and let the rest of the streams
     // get a normal unacknowledged stream error.
     ProxygenError err = kErrorStreamUnacknowledged;
     string debugInfo = (debugData) ?
       folly::to<string>(" with debug info: ", (char*)debugData->data()) : "";
     HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS,
       folly::to<std::string>(getErrorString(err),
         " on transaction id: ", *firstStream,
         " with codec error: ", getErrorCodeString(code),
         debugInfo));
     ex.setProxygenError(err);
     errorOnTransactionId(*firstStream, std::move(ex));
   } else if (firstStream != HTTPCodec::NoStream) {
     ids.push_back(*firstStream);
   }
 
   errorOnTransactionIds(ids, kErrorStreamUnacknowledged);
 }

void proxygen::HTTPSession::onHeadersComplete	(	HTTPCodec::StreamID	stream,
		std::unique_ptr< HTTPMessage >	msg
	)

overrideprotectedvirtual

Called when all the headers of an ingress message have been parsed

Parameters

stream	The stream ID
msg	The message
size	Size of the ingress header

References proxygen::HTTPSessionBase::codec_, findTransaction(), proxygen::HTTPTransaction::getControlStream(), proxygen::HTTPSessionBase::infoCallback_, proxygen::HTTPException::INGRESS_AND_EGRESS, invalidStream(), proxygen::HTTPTransaction::isRemoteInitiated(), proxygen::HTTPCodec::isReusable(), folly::gen::move, onError(), proxygen::HTTPSessionBase::InfoCallback::onIngressMessage(), proxygen::REFUSED_STREAM, proxygen::REQ_NOTREUSABLE, wangle::TransportInfo::secure, proxygen::HTTPSessionBase::setCloseReason(), proxygen::HTTPException::setCodecStatusCode(), setupOnHeadersComplete(), wangle::TransportInfo::sslCipher, wangle::TransportInfo::sslVersion, streamID, and proxygen::HTTPSessionBase::transportInfo_.

Definition at line 899 of file HTTPSession.cpp.

Referenced by getSecurityProtocol().

                                                             {
   // The codec's parser detected the end of an ingress message's
   // headers.
   VLOG(4) << "processing ingress headers complete for " << *this <<
       ", streamID=" << streamID;
 
   if (!codec_->isReusable()) {
     setCloseReason(ConnectionCloseReason::REQ_NOTREUSABLE);
   }
 
   if (infoCallback_) {
     infoCallback_->onIngressMessage(*this, *msg.get());
   }
   HTTPTransaction* txn = findTransaction(streamID);
   if (!txn) {
     invalidStream(streamID);
     return;
   }
 
   const char* sslCipher =
       transportInfo_.sslCipher ? transportInfo_.sslCipher->c_str() : nullptr;
   msg->setSecureInfo(transportInfo_.sslVersion, sslCipher);
   msg->setSecure(transportInfo_.secure);
 
   auto controlStreamID = txn->getControlStream();
   if (controlStreamID) {
     auto controlTxn = findTransaction(*controlStreamID);
     if (!controlTxn) {
       VLOG(2) << "txn=" << streamID << " with a broken controlTxn="
               << *controlStreamID << " " << *this;
       HTTPException ex(
           HTTPException::Direction::INGRESS_AND_EGRESS,
           folly::to<std::string>("broken controlTxn ", *controlStreamID));
       onError(streamID, ex, true);
       return;
     }
 
     // Call onExTransaction() only for requests.
     if (txn->isRemoteInitiated() && !controlTxn->onExTransaction(txn)) {
       VLOG(2) << "Failed to add exTxn=" << streamID
               << " to controlTxn=" << *controlStreamID << ", " << *this;
       HTTPException ex(
           HTTPException::Direction::INGRESS_AND_EGRESS,
           folly::to<std::string>("Fail to add exTxn ", streamID));
       ex.setCodecStatusCode(ErrorCode::REFUSED_STREAM);
       onError(streamID, ex, true);
       return;
     }
   } else {
     setupOnHeadersComplete(txn, msg.get());
   }
 
   // The txn may have already been aborted by the handler.
   // Verify that the txn still exists before ingress callbacks.
   txn = findTransaction(streamID);
   if (!txn) {
     return;
   }
 
   if (!txn->getHandler()) {
     txn->sendAbort();
     return;
   }
 
   // Tell the Transaction to start processing the message now
   // that the full ingress headers have arrived.
   txn->onIngressHeadersComplete(std::move(msg));
 }

virtual void proxygen::HTTPSession::onHeadersSent	(	const HTTPMessage &	,
		bool
	)

inlineprotectedvirtual

Invoked when headers have been sent.

Reimplemented in proxygen::HTTPDownstreamSession.

Definition at line 300 of file HTTPSession.h.

References allTransactionsStarted(), decrementTransactionCount(), getCodecSendWindowSize(), getNextToSend(), onEgressMessageFinished(), onNativeProtocolUpgradeImpl(), sendPriorityImpl(), setNewTransactionPauseState(), streamID, and string.

Referenced by sendHeaders().

302 {}

void proxygen::HTTPSession::onLastByteEvent	(	HTTPTransaction *	txn,
		uint64_t	offset,
		bool	eomTracked
	)

overrideprivatevirtualnoexcept

Implements proxygen::ByteEventTracker::Callback.

Definition at line 2962 of file HTTPSession.cpp.

References byteEventTracker_, and sock_.

Referenced by isConnWindowFull().

                                                                         {
   if (!sock_->isEorTrackingEnabled() || !eomTracked) {
     return;
   }
 
   if (eomOffset != sock_->getAppBytesWritten()) {
     VLOG(2) << "tracking ack to last app byte " << eomOffset
         << " while " << sock_->getAppBytesWritten()
         << " app bytes have already been written";
     return;
   }
 
   VLOG(5) << "tracking raw last byte " << sock_->getRawBytesWritten()
           << " while the app last byte is " << eomOffset;
 
   byteEventTracker_->addAckByteEvent(sock_->getRawBytesWritten(), txn);
 }

void proxygen::HTTPSession::onMessageBegin	(	HTTPCodec::StreamID	stream,
		HTTPMessage *	msg
	)

overrideprotectedvirtual

Called when a new message is seen while parsing the ingress

Parameters

stream	The stream ID
msg	A newly allocated HTTPMessage

References byteEventTracker_, proxygen::HTTPSessionBase::codec_, createTransaction(), findTransaction(), getMessagePriority(), getPipelineStreamCount(), proxygen::HTTPSessionBase::infoCallback_, proxygen::HTTPException::INGRESS_AND_EGRESS, isDownstream(), proxygen::HTTPTransaction::isPushed(), liveTransactions_, proxygen::HTTPCodec::NoExAttributes, proxygen::HTTPCodec::NoStream, proxygen::HTTPTransaction::onError(), proxygen::HTTPSessionBase::InfoCallback::onRequestBegin(), readsPaused(), readsUnpaused(), proxygen::HTTPException::setCodecStatusCode(), proxygen::STREAM_CLOSED, proxygen::HTTPCodec::supportsParallelRequests(), and transactions_.

Definition at line 758 of file HTTPSession.cpp.

Referenced by getSecurityProtocol().

                                                                         {
   VLOG(4) << "processing new msg streamID=" << streamID << " " << *this;
   if (infoCallback_) {
     infoCallback_->onRequestBegin(*this);
   }
 
   HTTPTransaction* txn = findTransaction(streamID);
   if (txn) {
     if (isDownstream() && txn->isPushed()) {
       // Push streams are unidirectional (half-closed). If the downstream
       // attempts to send ingress, abort with STREAM_CLOSED error.
       HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS,
                        "Downstream attempts to send ingress, abort.");
       ex.setCodecStatusCode(ErrorCode::STREAM_CLOSED);
       txn->onError(ex);
     }
     return;  // If this transaction is already registered, no need to add it now
   }
 
   http2::PriorityUpdate messagePriority = getMessagePriority(msg);
   txn = createTransaction(streamID, HTTPCodec::NoStream,
                           HTTPCodec::NoExAttributes, messagePriority);
   if (!txn) {
     return;  // This could happen if the socket is bad.
   }
 
   if (!codec_->supportsParallelRequests() && getPipelineStreamCount() > 1) {
     // The previous transaction hasn't completed yet. Pause reads until
     // it completes; this requires pausing both transactions.
 
     // HTTP/1.1 pipeline is detected, and which is incompactible with
     // ByteEventTracker. Drain all the ByteEvents
     CHECK(byteEventTracker_);
     byteEventTracker_->drainByteEvents();
 
     // drainByteEvents() may detach txn(s). Don't pause read if one txn left
     if (getPipelineStreamCount() < 2) {
       DCHECK(readsUnpaused());
       return;
     }
 
     // There must be at least two transactions (we just checked). The previous
     // txns haven't completed yet. Pause reads until they complete
     DCHECK_GE(transactions_.size(), 2);
     for (auto it = ++transactions_.rbegin(); it != transactions_.rend(); ++it) {
       DCHECK(it->second.isIngressEOMSeen());
       it->second.pauseIngress();
     }
     transactions_.rbegin()->second.pauseIngress();
     DCHECK_EQ(liveTransactions_, 0);
     DCHECK(readsPaused());
   }
 }

void proxygen::HTTPSession::onMessageComplete	(	HTTPCodec::StreamID	stream,
		bool	upgrade
	)

overrideprotectedvirtual

Called at end of a message (including body and trailers, if applicable)

Parameters

stream	The stream ID
upgrade	Whether the connection has been upgraded to another protocol.

References proxygen::HTTPSessionBase::codec_, decrementTransactionCount(), proxygen::HTTPTransaction::extraResponseExpected(), findTransaction(), ingressUpgraded_, invalidStream(), proxygen::HTTPTransaction::isDownstream(), proxygen::HTTPCodec::isReusable(), proxygen::HTTPTransaction::onIngressEOM(), proxygen::HTTPTransaction::onIngressUpgrade(), shutdownTransport(), streamID, proxygen::HTTPCodec::supportsParallelRequests(), and proxygen::TCP.

Definition at line 1041 of file HTTPSession.cpp.

Referenced by getSecurityProtocol().

                                              {
   DestructorGuard dg(this);
   // The codec's parser detected the end of the ingress message for
   // this transaction.
   VLOG(4) << "processing ingress message complete for " << *this <<
     ", streamID=" << streamID;
   HTTPTransaction* txn = findTransaction(streamID);
   if (!txn) {
     invalidStream(streamID);
     return;
   }
 
   if (upgrade) {
     /* Send the upgrade callback to the transaction and the handler.
      * Currently we support upgrades for only HTTP sessions and not SPDY
      * sessions.
      */
     ingressUpgraded_ = true;
     txn->onIngressUpgrade(UpgradeProtocol::TCP);
     return;
   }
 
   // txnIngressFinished = !1xx response
   const bool txnIngressFinished =
     txn->isDownstream() || !txn->extraResponseExpected();
   if (txnIngressFinished) {
     decrementTransactionCount(txn, true, false);
   }
   txn->onIngressEOM();
 
   // The codec knows, based on the semantics of whatever protocol it
   // supports, whether it's valid for any more ingress messages to arrive
   // after this one.  For example, an HTTP/1.1 request containing
   // "Connection: close" indicates the end of the ingress, whereas a
   // SPDY session generally can handle more messages at any time.
   //
   // If the connection is not reusable, we close the read side of it
   // but not the write side.  There are two reasons why more writes
   // may occur after this point:
   //   * If there are previous writes buffered up in the pendingWrites_
   //     queue, we need to attempt to complete them.
   //   * The Handler associated with the transaction may want to
   //     produce more egress data when the ingress message is fully
   //     complete.  (As a common example, an application that handles
   //     form POSTs may not be able to even start generating a response
   //     until it has received the full request body.)
   //
   // There may be additional checks that need to be performed that are
   // specific to requests or responses, so we call the subclass too.
   if (!codec_->isReusable() &&
       txnIngressFinished &&
       !codec_->supportsParallelRequests()) {
     VLOG(4) << *this << " cannot reuse ingress";
     shutdownTransport(true, false);
   }
 }

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

protected

Definition at line 1413 of file HTTPSession.cpp.

References wangle::TransportInfo::appProtocol, proxygen::HTTPSessionBase::codec_, connFlowControl_, proxygen::HTTPCodec::createStream(), findTransaction(), getCodecSendWindowSize(), proxygen::HTTPCodec::getDefaultWindowSize(), proxygen::HTTPCodec::getEgressSettings(), proxygen::INITIAL_WINDOW_SIZE, initialReceiveWindow_, maxConcurrentIncomingStreams_, maxConcurrentOutgoingStreamsRemote_, folly::gen::move, proxygen::HTTPSessionBase::onCodecChanged(), receiveSessionWindowSize_, receiveStreamWindowSize_, proxygen::HTTPTransaction::reset(), scheduleWrite(), wangle::TransportInfo::secure, sendSettings(), proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::setDestination(), proxygen::FlowControlFilter::setReceiveWindowSize(), proxygen::HTTPSettings::setSetting(), settings, setupCodec(), sock_, proxygen::HTTPCodec::supportsParallelRequests(), proxygen::HTTPCodec::supportsStreamFlowControl(), proxygen::HTTPSessionBase::transportInfo_, and writeBuf_.

Referenced by onHeadersSent(), proxygen::HTTPDownstreamSession::onNativeProtocolUpgrade(), and proxygen::HTTPUpstreamSession::onNativeProtocolUpgrade().

                                    {
   CHECK_EQ(streamID, 1);
   HTTPTransaction* txn = findTransaction(streamID);
   CHECK(txn);
   // only HTTP1xCodec calls onNativeProtocolUpgrade
   CHECK(!codec_->supportsParallelRequests());
 
   // Reset to  defaults
   maxConcurrentIncomingStreams_ = 100;
   maxConcurrentOutgoingStreamsRemote_ = 10000;
 
   // overwrite destination, delay current codec deletion until the end
   // of the event loop
   auto oldCodec = codec_.setDestination(std::move(codec));
   sock_->getEventBase()->runInLoop([oldCodec = std::move(oldCodec)] () {});
 
   onCodecChanged();
 
   setupCodec();
 
   // txn will be streamID=1, have to make a placeholder
   (void)codec_->createStream();
 
   // This can happen if flow control was not explicitly set, and it got the
   // HTTP1xCodec defaults.  Reset to the new codec default
   if (initialReceiveWindow_ == 0 || receiveStreamWindowSize_ == 0 ||
       receiveSessionWindowSize_ == 0) {
     initialReceiveWindow_ = receiveStreamWindowSize_ =
       receiveSessionWindowSize_ = codec_->getDefaultWindowSize();
   }
 
   // trigger settings frame that would have gone out in startNow()
   HTTPSettings* settings = codec_->getEgressSettings();
   if (settings) {
     settings->setSetting(SettingsId::INITIAL_WINDOW_SIZE,
                          initialReceiveWindow_);
   }
   sendSettings();
   if (connFlowControl_) {
     connFlowControl_->setReceiveWindowSize(writeBuf_,
                                            receiveSessionWindowSize_);
     scheduleWrite();
   }
 
   // Convert the transaction that contained the Upgrade header
   txn->reset(codec_->supportsStreamFlowControl(),
              initialReceiveWindow_,
              receiveStreamWindowSize_,
              getCodecSendWindowSize());
 
   if (!transportInfo_.secure &&
       (!transportInfo_.appProtocol ||
        transportInfo_.appProtocol->empty())) {
     transportInfo_.appProtocol = std::make_shared<string>(
       protocolString);
   }
 
   return true;
 }

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

protected

Send a transaction abort and leave the session and transport intact.

Definition at line 2742 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::generateRstStream(), proxygen::HTTPException::getCodecStatusCode(), proxygen::HTTPException::hasCodecStatusCode(), proxygen::HTTPCodec::isReusable(), scheduleWrite(), proxygen::SESSION_PARSE_ERROR, proxygen::HTTPSessionBase::setCloseReason(), and writeBuf_.

Referenced by onError(), and sessionByteOffset().

                                                                          {
   VLOG(4) << *this << " parse error with new transaction";
   if (error.hasCodecStatusCode()) {
     codec_->generateRstStream(writeBuf_, streamID, error.getCodecStatusCode());
     scheduleWrite();
   }
   if (!codec_->isReusable()) {
     // HTTP 1x codec does not support per stream abort so this will
     // render the codec not reusable
     setCloseReason(ConnectionCloseReason::SESSION_PARSE_ERROR);
   }
 }

void proxygen::HTTPSession::onPingReply ( uint64_t )

overrideprotectedvirtual

Called upon receipt of a ping reply

Parameters

uniqueID Unique identifier for the ping

Note: Not all protocols have pings. SPDY does, but HTTP/1.1 doesn't.

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 1278 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::infoCallback_, and proxygen::HTTPSessionBase::InfoCallback::onPingReplyReceived().

Referenced by getSecurityProtocol().

                                                {
   VLOG(4) << *this << " got ping reply with id=" << uniqueID;
   if (infoCallback_) {
     infoCallback_->onPingReplyReceived();
   }
 }

void proxygen::HTTPSession::onPingReplyLatency ( int64_t latency )

overrideprivatevirtualnoexcept

Implements proxygen::ByteEventTracker::Callback.

Definition at line 2924 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::infoCallback_, and proxygen::HTTPSessionBase::InfoCallback::onPingReplySent().

Referenced by isConnWindowFull().

                                                              {
   if (infoCallback_ && latency >= 0) {
     infoCallback_->onPingReplySent(latency);
   }
 }

void proxygen::HTTPSession::onPingRequest ( uint64_t )

overrideprotectedvirtual

Called upon receipt of a ping request

Parameters

uniqueID Unique identifier for the ping

Note: Not all protocols have pings. SPDY does, but HTTP/1.1 doesn't.

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 1259 of file HTTPSession.cpp.

References folly::IOBufQueue::append(), byteEventTracker_, bytesScheduled_, folly::IOBufQueue::cacheChainLength(), folly::IOBufQueue::chainLength(), proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::generatePingReply(), proxygen::getCurrentTime(), folly::IOBufQueue::move(), scheduleWrite(), and writeBuf_.

Referenced by getSecurityProtocol().

                                                  {
   VLOG(4) << *this << " got ping request with id=" << uniqueID;
 
   TimePoint timestamp = getCurrentTime();
 
   // Insert the ping reply to the head of writeBuf_
   folly::IOBufQueue pingBuf(folly::IOBufQueue::cacheChainLength());
   codec_->generatePingReply(pingBuf, uniqueID);
   size_t pingSize = pingBuf.chainLength();
   pingBuf.append(writeBuf_.move());
   writeBuf_.append(pingBuf.move());
 
   if (byteEventTracker_) {
     byteEventTracker_->addPingByteEvent(pingSize, timestamp, bytesScheduled_);
   }
 
   scheduleWrite();
 }

void proxygen::HTTPSession::onPriority	(	HTTPCodec::StreamID	,
		const HTTPMessage::HTTPPriority &
	)

overrideprotectedvirtual

Called upon receipt of a priority frame, for protocols that support dynamic priority

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 1330 of file HTTPSession.cpp.

References proxygen::HTTP2PriorityQueue::addOrUpdatePriorityNode(), findTransaction(), getHTTP2PrioritiesEnabled(), and txnEgressQueue_.

Referenced by getSecurityProtocol().

                                                                  {
   if (!getHTTP2PrioritiesEnabled()) {
     return;
   }
   http2::PriorityUpdate h2Pri{std::get<0>(pri), std::get<1>(pri),
       std::get<2>(pri)};
   HTTPTransaction* txn = findTransaction(streamID);
   if (txn) {
     // existing txn, change pri
     txn->onPriorityUpdate(h2Pri);
   } else {
     // virtual node
     txnEgressQueue_.addOrUpdatePriorityNode(streamID, h2Pri);
   }
 }

void proxygen::HTTPSession::onPushMessageBegin	(	HTTPCodec::StreamID	,
		HTTPCodec::StreamID	,
		HTTPMessage *
	)

overrideprotectedvirtual

Called when a new push message is seen while parsing the ingress.

Parameters

stream	The stream ID
assocStream	The stream ID of the associated stream, which can never be 0
msg	A newly allocated HTTPMessage

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 813 of file HTTPSession.cpp.

References createTransaction(), findTransaction(), getMessagePriority(), proxygen::HTTPSessionBase::infoCallback_, proxygen::HTTPException::INGRESS_AND_EGRESS, invalidStream(), isDownstream(), proxygen::HTTPTransaction::isIngressEOMSeen(), proxygen::HTTPCodec::NoExAttributes, onError(), proxygen::HTTPTransaction::onPushedTransaction(), proxygen::HTTPSessionBase::InfoCallback::onRequestBegin(), proxygen::PROTOCOL_ERROR, proxygen::REFUSED_STREAM, and proxygen::HTTPException::setCodecStatusCode().

Referenced by getSecurityProtocol().

                                                   {
   VLOG(4) << "processing new push promise streamID=" << streamID
           << " on assocStreamID=" << assocStreamID << " " << *this;
   if (infoCallback_) {
     infoCallback_->onRequestBegin(*this);
   }
   if (assocStreamID == 0) {
     VLOG(2) << "push promise " << streamID << " should be associated with "
             << "an active stream=" << assocStreamID << " " << *this;
     invalidStream(streamID, ErrorCode::PROTOCOL_ERROR);
     return;
   }
 
   if (isDownstream()) {
     VLOG(2) << "push promise cannot be sent to upstream " << *this;
     invalidStream(streamID, ErrorCode::PROTOCOL_ERROR);
     return;
   }
 
   HTTPTransaction* assocTxn = findTransaction(assocStreamID);
   if (!assocTxn || assocTxn->isIngressEOMSeen()) {
     VLOG(2) << "cannot find the assocTxn=" << assocTxn
             << ", or assoc stream is already closed by upstream" << *this;
     invalidStream(streamID, ErrorCode::PROTOCOL_ERROR);
     return;
   }
 
   http2::PriorityUpdate messagePriority = getMessagePriority(msg);
   auto txn = createTransaction(streamID, assocStreamID,
                                HTTPCodec::NoExAttributes, messagePriority);
   if (!txn) {
     return;  // This could happen if the socket is bad.
   }
 
   if (!assocTxn->onPushedTransaction(txn)) {
     VLOG(1) << "Failed to add pushed txn " << streamID
             << " to assoc txn " << assocStreamID << " on " << *this;
     HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS,
       folly::to<std::string>("Failed to add pushed transaction ", streamID));
     ex.setCodecStatusCode(ErrorCode::REFUSED_STREAM);
     onError(streamID, ex, true);
   }
 }

void proxygen::HTTPSession::onReplaySafe ( )

overrideprivatevirtualnoexcept

Callback from the transport to this HTTPSession to signal when the transport has become replay safe.

Implements folly::AsyncTransport::ReplaySafetyCallback.

Definition at line 2948 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::infoCallback_, proxygen::HTTPSessionBase::InfoCallback::onFullHandshakeCompletion(), sock_, and waitingForReplaySafety_.

Referenced by needToBlockForReplaySafety().

                                         {
   CHECK(sock_);
   sock_->setReplaySafetyCallback(nullptr);
 
   if (infoCallback_) {
     infoCallback_->onFullHandshakeCompletion(*this);
   }
 
   for (auto callback : waitingForReplaySafety_) {
     callback->onReplaySafe();
   }
   waitingForReplaySafety_.clear();
 }

void proxygen::HTTPSession::onSessionParseError ( const HTTPException & error )

protected

Send a session layer abort and shutdown the transport for reads and writes.

Definition at line 2726 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, folly::IOBuf::copyBuffer(), proxygen::HTTPCodec::generateGoaway(), proxygen::HTTPException::getCodecStatusCode(), proxygen::HTTPCodec::getLastIncomingStreamID(), proxygen::HTTPCodec::getProtocol(), proxygen::HTTPException::hasCodecStatusCode(), proxygen::isHTTP2CodecProtocol(), folly::gen::move, scheduleWrite(), proxygen::SESSION_PARSE_ERROR, proxygen::HTTPSessionBase::setCloseReason(), shutdownTransport(), proxygen::Exception::what(), and writeBuf_.

Referenced by onError(), and sessionByteOffset().

                                                                 {
   VLOG(4) << *this << " session layer parse error. Terminate the session.";
   if (error.hasCodecStatusCode()) {
     std::unique_ptr<folly::IOBuf> errorMsg =
       folly::IOBuf::copyBuffer(error.what());
     codec_->generateGoaway(writeBuf_,
                            codec_->getLastIncomingStreamID(),
                            error.getCodecStatusCode(),
                            isHTTP2CodecProtocol(codec_->getProtocol()) ?
                            std::move(errorMsg) : nullptr);
     scheduleWrite();
   }
   setCloseReason(ConnectionCloseReason::SESSION_PARSE_ERROR);
   shutdownTransport(true, true);
 }

void proxygen::HTTPSession::onSetMaxInitiatedStreams ( uint32_t maxTxns )

private

Definition at line 1481 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::infoCallback_, maxConcurrentOutgoingStreamsRemote_, proxygen::HTTPSessionBase::InfoCallback::onSettingsOutgoingStreamsFull(), proxygen::HTTPSessionBase::InfoCallback::onSettingsOutgoingStreamsNotFull(), and proxygen::HTTPSessionBase::supportsMoreTransactions().

Referenced by getMaxConcurrentOutgoingStreamsRemote(), and onSettings().

                                                            {
   VLOG(4) << *this << " got new maximum number of concurrent txns "
           << "we can initiate: " << maxTxns;
   const bool didSupport = supportsMoreTransactions();
   maxConcurrentOutgoingStreamsRemote_ = maxTxns;
   if (infoCallback_ && didSupport != supportsMoreTransactions()) {
     if (didSupport) {
       infoCallback_->onSettingsOutgoingStreamsFull(*this);
     } else {
       infoCallback_->onSettingsOutgoingStreamsNotFull(*this);
     }
   }
 }

void proxygen::HTTPSession::onSetSendWindow ( uint32_t windowSize )

private

Definition at line 1475 of file HTTPSession.cpp.

References invokeOnAllTransactions(), and proxygen::HTTPTransaction::onIngressSetSendWindow().

Referenced by getMaxConcurrentOutgoingStreamsRemote(), and onSettings().

                                                      {
   VLOG(4) << *this << " got send window size adjustment. new=" << windowSize;
   invokeOnAllTransactions(&HTTPTransaction::onIngressSetSendWindow,
                           windowSize);
 }

void proxygen::HTTPSession::onSettings ( const SettingsList & )

overrideprotectedvirtual

Called upon receipt of a settings frame, for protocols that support settings.

Parameters

settings a list of settings that were sent in the settings frame

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 1302 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, g(), proxygen::HTTPCodec::generateSettingsAck(), proxygen::HTTPSessionBase::infoCallback_, proxygen::INITIAL_WINDOW_SIZE, proxygen::MAX_CONCURRENT_STREAMS, onSetMaxInitiatedStreams(), onSetSendWindow(), proxygen::HTTPSessionBase::InfoCallback::onSettings(), scheduleWrite(), proxygen::SETTINGS_HTTP_CERT_AUTH, verifyCertAuthSetting(), and writeBuf_.

Referenced by getSecurityProtocol().

                                                          {
   DestructorGuard g(this);
   for (auto& setting : settings) {
     if (setting.id == SettingsId::INITIAL_WINDOW_SIZE) {
       onSetSendWindow(setting.value);
     } else if (setting.id == SettingsId::MAX_CONCURRENT_STREAMS) {
       onSetMaxInitiatedStreams(setting.value);
     } else if (setting.id == SettingsId::SETTINGS_HTTP_CERT_AUTH) {
       if (!(verifyCertAuthSetting(setting.value))) {
         return;
       }
     }
   }
   if (codec_->generateSettingsAck(writeBuf_) > 0) {
     scheduleWrite();
   }
   if (infoCallback_) {
     infoCallback_->onSettings(*this, settings);
   }
 }

void proxygen::HTTPSession::onSettingsAck ( )

overrideprotectedvirtual

Called upon receipt of a settings frame with ACK set, for protocols that support settings ack.

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 1323 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::infoCallback_, and proxygen::HTTPSessionBase::InfoCallback::onSettingsAck().

Referenced by getSecurityProtocol().

                                 {
   VLOG(4) << *this << " received settings ack";
   if (infoCallback_) {
     infoCallback_->onSettingsAck(*this);
   }
 }

void proxygen::HTTPSession::onTrailersComplete	(	HTTPCodec::StreamID	stream,
		std::unique_ptr< HTTPHeaders >	trailers
	)

overrideprotectedvirtual

Called when all the trailers of an ingress message have been parsed, but only if the number of trailers is nonzero.

Parameters

stream	The stream ID
trailers	The message trailers

References proxygen::HTTPSessionBase::infoCallback_, proxygen::IO_WRITE_ERROR, proxygen::kErrorWrite, proxygen::HTTPSessionBase::InfoCallback::onWrite(), proxygen::HTTPSessionBase::setCloseReason(), shutdownTransportWithReset(), folly::SSL_ERROR, wangle::TransportInfo::sslError, and proxygen::HTTPSessionBase::transportInfo_.

Definition at line 1030 of file HTTPSession.cpp.

References findTransaction(), invalidStream(), folly::gen::move, and proxygen::HTTPTransaction::onIngressTrailers().

Referenced by getSecurityProtocol().

                                                                   {
   HTTPTransaction* txn = findTransaction(streamID);
   if (!txn) {
     invalidStream(streamID);
     return;
   }
   txn->onIngressTrailers(std::move(trailers));
 }

void proxygen::HTTPSession::onWindowUpdate	(	HTTPCodec::StreamID	,
		uint32_t
	)

overrideprotectedvirtual

Called upon receipt of a window update, for protocols that support flow control. For instance spdy/3 and higher.

Reimplemented from proxygen::HTTPCodec::Callback.

Definition at line 1285 of file HTTPSession.cpp.

References findTransaction(), and proxygen::HTTPTransaction::onIngressWindowUpdate().

Referenced by getSecurityProtocol().

                                                   {
   VLOG(4) << *this << " got window update on streamID=" << streamID << " for "
           << amount << " bytes.";
   HTTPTransaction* txn = findTransaction(streamID);
   if (!txn) {
     // We MUST be using SPDY/3+ if we got WINDOW_UPDATE. The spec says that -
     //
     // A sender should ignore all the WINDOW_UPDATE frames associated with the
     // stream after it send the last frame for the stream.
     //
     // TODO: Only ignore if this is from some past transaction
     return;
   }
   txn->onIngressWindowUpdate(amount);
 }

void proxygen::HTTPSession::onWriteCompleted ( )

protected

Check whether to shut down the transport after a write completes.

Definition at line 2708 of file HTTPSession.cpp.

References numActiveWrites_, pendingWrites_, shutdownTransport(), and writesDraining_.

Referenced by onWriteSuccess(), and sessionByteOffset().

                               {
   if (!writesDraining_) {
     return;
   }
 
   if (numActiveWrites_) {
     return;
   }
 
   // Don't shutdown if there might be more writes
   if (!pendingWrites_.empty()) {
     return;
   }
 
   // All finished draining writes, so shut down the egress
   shutdownTransport(false, true);
 }

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

protected

Invoked by WriteSegment on write failure.

Definition at line 2690 of file HTTPSession.cpp.

Referenced by sessionByteOffset(), and proxygen::HTTPSession::WriteSegment::writeErr().

                                                           {
   VLOG(4) << *this << " write error: " << ex.what();
   if (infoCallback_) {
     infoCallback_->onWrite(*this, bytesWritten);
   }
 
   auto sslEx = dynamic_cast<const folly::SSLException*>(&ex);
   // Save the SSL error, if there was one.  It will be recorded later
   if (sslEx && sslEx->getSSLError() == folly::SSLError::SSL_ERROR) {
     transportInfo_.sslError = ex.what();
   }
 
   setCloseReason(ConnectionCloseReason::IO_WRITE_ERROR);
   shutdownTransportWithReset(kErrorWrite, ex.what());
 }

void proxygen::HTTPSession::onWriteSuccess ( uint64_t bytesWritten )

protected

Invoked by WriteSegment on completion of a write.

Definition at line 2631 of file HTTPSession.cpp.

References byteEventTracker_, bytesWritten_, folly::HHWheelTimer::Callback::cancelTimeout(), proxygen::HTTPSessionBase::codec_, egressBytesLimit_, hasMoreWrites(), proxygen::HTTPSessionBase::infoCallback_, inLoopCallback_, proxygen::HTTPCodec::isReusable(), folly::HHWheelTimer::Callback::isScheduled(), numActiveWrites_, proxygen::HTTPSessionBase::InfoCallback::onWrite(), onWriteCompleted(), pendingWrites_, readsShutdown(), runLoopCallback(), proxygen::WheelTimerInstance::scheduleTimeout(), proxygen::HTTPSessionBase::setCloseReason(), shutdownTransport(), timeout_, wangle::TransportInfo::totalBytes, transactions_, proxygen::HTTPSessionBase::transportInfo_, proxygen::UNKNOWN, updateWriteBufSize(), updateWriteCount(), and writeTimeout_.

Referenced by sessionByteOffset(), and proxygen::HTTPSession::WriteSegment::writeSuccess().

                                                  {
   DestructorGuard dg(this);
   bytesWritten_ += bytesWritten;
   transportInfo_.totalBytes += bytesWritten;
   CHECK(writeTimeout_.isScheduled());
   if (pendingWrites_.empty()) {
     VLOG(10) << "Cancel write timer on last successful write";
     writeTimeout_.cancelTimeout();
   } else {
     VLOG(10) << "Refresh write timer on writeSuccess";
     timeout_.scheduleTimeout(&writeTimeout_);
   }
 
   if (infoCallback_) {
     infoCallback_->onWrite(*this, bytesWritten);
   }
 
   VLOG(5) << "total bytesWritten_: " << bytesWritten_;
 
   // processByteEvents will return true if it has been replaced with another
   // tracker in the middle and needs to be re-run.  Should happen at most
   // once.  while with no body is intentional
   while (byteEventTracker_ &&
          byteEventTracker_->processByteEvents(
            byteEventTracker_, bytesWritten_)) {} // pass
 
   if ((!codec_->isReusable() || readsShutdown()) && (transactions_.empty())) {
     if (!codec_->isReusable()) {
       // Shouldn't happen unless there is a bug. This can only happen when
       // someone calls shutdownTransport, but did not specify a reason before.
       setCloseReason(ConnectionCloseReason::UNKNOWN);
     }
     VLOG(4) << *this << " shutdown from onWriteSuccess";
     shutdownTransport(true, true);
   }
   numActiveWrites_--;
   if (!inLoopCallback_) {
     updateWriteCount();
     // safe to resume here:
     updateWriteBufSize(-folly::to<int64_t>(bytesWritten));
     // PRIO_FIXME: this is done because of the corking business...
     //             in the future we may want to have a pull model
     //             whereby the socket asks us for a given amount of
     //             data to send...
     if (numActiveWrites_ == 0 && hasMoreWrites()) {
       runLoopCallback();
     }
   }
   onWriteCompleted();
 
   if (egressBytesLimit_ > 0 && bytesWritten_ >= egressBytesLimit_) {
     VLOG(4) << "Egress limit reached, shutting down "
       "session (egressed " << bytesWritten_ << ", limit set to "
       << egressBytesLimit_ << ")";
     shutdownTransport(true, true);
   }
 }

void proxygen::HTTPSession::pauseIngress ( HTTPTransaction * txn )

overrideprotectedvirtualnoexcept

Definition at line 1501 of file HTTPSession.cpp.

References findTransaction(), liveTransactions_, and pauseReads().

Referenced by numIncomingStreams().

                                                             {
   VLOG(4) << *this << " pausing streamID=" << txn->getID() <<
     ", liveTransactions_ was " << liveTransactions_;
   CHECK_GT(liveTransactions_, 0);
   --liveTransactions_;
   auto exTxns = txn->getExTransactions();
   for (auto it = exTxns.begin(); it != exTxns.end(); ++it) {
     auto exTxn = findTransaction(*it);
     if (exTxn) {
       exTxn->pauseIngress();
     }
   }
 
   if (liveTransactions_ == 0) {
     pauseReads();
   }
 }

void proxygen::HTTPSession::pauseReads ( )

protected

Stop reading from the transport until resumeReads() is called

Definition at line 2757 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPSessionBase::ingressLimitExceeded(), pauseReadsImpl(), readsUnpaused(), proxygen::HTTPCodec::setParserPaused(), and proxygen::HTTPCodec::supportsParallelRequests().

Referenced by onBody(), pauseIngress(), and sessionByteOffset().

                         {
   // Make sure the parser is paused.  Note that if reads are shutdown
   // before they are paused, we never make it past the if.
   codec_->setParserPaused(true);
   if (!readsUnpaused() ||
       (codec_->supportsParallelRequests() &&
        !ingressLimitExceeded())) {
     return;
   }
   pauseReadsImpl();
 }

void proxygen::HTTPSession::pauseReadsImpl ( )

protected

Definition at line 2769 of file HTTPSession.cpp.

References folly::HHWheelTimer::Callback::cancelTimeout(), proxygen::HTTPSessionBase::infoCallback_, proxygen::HTTPSessionBase::InfoCallback::onIngressPaused(), reads_, and sock_.

Referenced by proxygen::HTTPUpstreamSession::detachThreadLocals(), invokeOnAllTransactions(), and pauseReads().

                                  {
   VLOG(4) << *this << ": pausing reads";
   if (infoCallback_) {
     infoCallback_->onIngressPaused(*this);
   }
   cancelTimeout();
   sock_->setReadCB(nullptr);
   reads_ = SocketState::PAUSED;
 }

void proxygen::HTTPSession::processReadData ( )

protected

Definition at line 575 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, FOLLY_SCOPED_TRACE_SECTION, folly::IOBufQueue::front(), ingressError_, folly::IOBuf::length(), proxygen::HTTPCodec::onIngress(), folly::IOBufQueue::pop_front(), readBuf_, readsUnpaused(), proxygen::HTTPCodec::setParserPaused(), and folly::IOBufQueue::trimStart().

Referenced by getHTTPPriority(), readBufferAvailable(), readDataAvailable(), and runLoopCallback().

                              {
   FOLLY_SCOPED_TRACE_SECTION("HTTPSession - processReadData");
   // skip any empty IOBufs before feeding CODEC.
   while (readBuf_.front() != nullptr && readBuf_.front()->length() == 0) {
     readBuf_.pop_front();
   }
 
   // Pass the ingress data through the codec to parse it. The codec
   // will invoke various methods of the HTTPSession as callbacks.
   const IOBuf* currentReadBuf;
   // It's possible for the last buffer in a chain to be empty here.
   // AsyncTransport saw fd activity so asked for a read buffer, but it was
   // SSL traffic and not enough to decrypt a whole record.  Later we invoke
   // this function from the loop callback.
   while (!ingressError_ &&
          readsUnpaused() &&
          ((currentReadBuf = readBuf_.front()) != nullptr &&
           currentReadBuf->length() != 0)) {
     // We're about to parse, make sure the parser is not paused
     codec_->setParserPaused(false);
     size_t bytesParsed = codec_->onIngress(*currentReadBuf);
     if (bytesParsed == 0) {
       // If the codec didn't make any progress with current input, we
       // better get more.
       break;
     }
     readBuf_.trimStart(bytesParsed);
   }
 }

void proxygen::HTTPSession::readBufferAvailable ( std::unique_ptr< folly::IOBuf > )

overrideprotectedvirtualnoexcept

readBufferAvailable() will be invoked when data has been successfully read.

Note that only either readBufferAvailable() or readDataAvailable() will be invoked according to the return value of isBufferMovable(). The timing and aftereffect of readBufferAvailable() are the same as readDataAvailable()

Parameters

readBuf The unique pointer of read buffer.

Reimplemented from folly::AsyncReader::ReadCallback.

Definition at line 557 of file HTTPSession.cpp.

References folly::IOBufQueue::append(), FOLLY_SCOPED_TRACE_SECTION, proxygen::HTTPSessionBase::infoCallback_, folly::gen::move, proxygen::HTTPSessionBase::InfoCallback::onRead(), processReadData(), fizz::detail::readBuf(), readBuf_, and wangle::ManagedConnection::resetTimeout().

Referenced by getHTTPPriority().

                                                                       {
   size_t readSize = readBuf->computeChainDataLength();
   FOLLY_SCOPED_TRACE_SECTION(
       "HTTPSession - readBufferAvailable", "readSize", readSize);
   VLOG(5) << "read completed on " << *this << ", bytes=" << readSize;
 
   DestructorGuard dg(this);
   resetTimeout();
   readBuf_.append(std::move(readBuf));
 
   if (infoCallback_) {
     infoCallback_->onRead(*this, readSize);
   }
 
   processReadData();
 }

void proxygen::HTTPSession::readDataAvailable ( size_t len )

overrideprotectedvirtualnoexcept

readDataAvailable() will be invoked when data has been successfully read into the buffer returned by the last call to getReadBuffer().

The read callback remains installed after readDataAvailable() returns. It must be explicitly uninstalled to stop receiving read events. getReadBuffer() will be called at least once before each call to readDataAvailable(). getReadBuffer() will also be called before any call to readEOF().

Parameters

len	The number of bytes placed in the buffer.

Definition at line 535 of file HTTPSession.cpp.

References FOLLY_SCOPED_TRACE_SECTION, proxygen::HTTPSessionBase::infoCallback_, proxygen::HTTPSessionBase::InfoCallback::onRead(), folly::IOBufQueue::postallocate(), processReadData(), readBuf_, and wangle::ManagedConnection::resetTimeout().

Referenced by getHTTPPriority().

                                                        {
   FOLLY_SCOPED_TRACE_SECTION(
       "HTTPSession - readDataAvailable", "readSize", readSize);
   VLOG(10) << "read completed on " << *this << ", bytes=" << readSize;
 
   DestructorGuard dg(this);
   resetTimeout();
   readBuf_.postallocate(readSize);
 
   if (infoCallback_) {
     infoCallback_->onRead(*this, readSize);
   }
 
   processReadData();
 }

void proxygen::HTTPSession::readEOF ( )

overrideprotectedvirtualnoexcept

readEOF() will be invoked when the transport is closed.

The read callback will be automatically uninstalled immediately before readEOF() is invoked.

References folly::IOBufQueue::empty(), proxygen::HTTPSessionBase::getNumTxnServed(), folly::gen::guard(), proxygen::HTTPSessionBase::infoCallback_, proxygen::kErrorClientSilent, proxygen::HTTPSessionBase::InfoCallback::onIngressError(), proxygen::READ_EOF, readBuf_, wangle::TransportInfo::secure, proxygen::HTTPSessionBase::setCloseReason(), shutdownTransport(), transactions_, and proxygen::HTTPSessionBase::transportInfo_.

Definition at line 606 of file HTTPSession.cpp.

Referenced by getHTTPPriority().

                               {
   DestructorGuard guard(this);
   VLOG(4) << "EOF on " << *this;
   // for SSL only: error without any bytes from the client might happen
   // due to client-side issues with the SSL cert. Note that it can also
   // happen if the client sends a SPDY frame header but no body.
   if (infoCallback_
       && transportInfo_.secure && getNumTxnServed() == 0 && readBuf_.empty()) {
     infoCallback_->onIngressError(*this, kErrorClientSilent);
   }
 
   // Shut down reads, and also shut down writes if there are no
   // transactions.  (If there are active transactions, leave the
   // write side of the socket open so those transactions can
   // finish generating responses.)
   setCloseReason(ConnectionCloseReason::READ_EOF);
   shutdownTransport(true, transactions_.empty());
 }

void proxygen::HTTPSession::readErr ( const folly::AsyncSocketException & ex )

overrideprotectedvirtualnoexcept

readError() will be invoked if an error occurs reading from the transport.

The read callback will be automatically uninstalled immediately before readError() is invoked.

Parameters

ex	An exception describing the error that occurred.

References folly::CLIENT_RENEGOTIATION, folly::gen::guard(), proxygen::HTTPSessionBase::infoCallback_, proxygen::IO_READ_ERROR, proxygen::kErrorClientRenegotiation, proxygen::HTTPSessionBase::InfoCallback::onIngressError(), proxygen::HTTPSessionBase::setCloseReason(), shutdownTransport(), folly::SSL_ERROR, wangle::TransportInfo::sslError, transactions_, and proxygen::HTTPSessionBase::transportInfo_.

Definition at line 626 of file HTTPSession.cpp.

Referenced by getHTTPPriority().

                                                             {
   DestructorGuard guard(this);
   VLOG(4) << "read error on " << *this << ": " << ex.what();
 
   auto sslEx = dynamic_cast<const folly::SSLException*>(&ex);
   if (infoCallback_ && sslEx) {
     if (sslEx->getSSLError() == folly::SSLError::CLIENT_RENEGOTIATION) {
       infoCallback_->onIngressError(*this, kErrorClientRenegotiation);
     }
   }
 
   // We're definitely finished reading. Don't close the write side
   // of the socket if there are outstanding transactions, though.
   // Instead, give the transactions a chance to produce any remaining
   // output.
   if (sslEx && sslEx->getSSLError() == folly::SSLError::SSL_ERROR) {
     transportInfo_.sslError = ex.what();
   }
   setCloseReason(ConnectionCloseReason::IO_READ_ERROR);
   shutdownTransport(true, transactions_.empty(), ex.what());
 }

bool proxygen::HTTPSession::readsPaused ( ) const

inlineprotected

Definition at line 630 of file HTTPSession.h.

References reads_.

Referenced by onMessageBegin(), and resumeReads().

                            {
     return reads_ == SocketState::PAUSED;
   }

bool proxygen::HTTPSession::readsShutdown ( ) const

inlineprotected

Definition at line 634 of file HTTPSession.h.

References reads_, and proxygen::SHUTDOWN.

Referenced by checkForShutdown(), detach(), dropConnection(), proxygen::HTTPUpstreamSession::isClosing(), onDeleteAckEvent(), onEgressMessageFinished(), onWriteSuccess(), shutdownTransport(), and shutdownTransportWithReset().

                              {
     return reads_ == SocketState::SHUTDOWN;
   }

bool proxygen::HTTPSession::readsUnpaused ( ) const

inlineprotected

Definition at line 626 of file HTTPSession.h.

References reads_.

Referenced by onMessageBegin(), pauseReads(), processReadData(), and runLoopCallback().

                              {
     return reads_ == SocketState::UNPAUSED;
   }

void proxygen::HTTPSession::readTimeoutExpired ( )

protectednoexcept

Definition at line 379 of file HTTPSession.cpp.

References drainTimeout_, proxygen::HTTPSessionBase::getController(), proxygen::HTTPSessionController::getGracefulShutdownTimeout(), liveTransactions_, notifyPendingShutdown(), wangle::ManagedConnection::resetTimeout(), proxygen::WheelTimerInstance::scheduleTimeout(), proxygen::HTTPSessionBase::setCloseReason(), proxygen::TIMEOUT, timeout_, and transactions_.

Referenced by getHTTPPriority(), and timeoutExpired().

                                          {
   VLOG(3) << "session-level timeout on " << *this;
 
   if (liveTransactions_ != 0) {
     // There's at least one open transaction with a read timeout scheduled.
     // We got here because the session timeout == the transaction timeout.
     // Ignore, since the transaction is going to timeout very soon.
     VLOG(4) << *this <<
         "ignoring session timeout, transaction timeout imminent";
     resetTimeout();
     return;
   }
 
   if (!transactions_.empty()) {
     // There are one or more transactions, but none of them are live.
     // That's valid if they've all received their full ingress messages
     // and are waiting for their Handlers to process those messages.
     VLOG(4) << *this <<
         "ignoring session timeout, no transactions awaiting reads";
     resetTimeout();
     return;
   }
 
   VLOG(4) << *this << " Timeout with nothing pending";
 
   setCloseReason(ConnectionCloseReason::TIMEOUT);
   auto controller = getController();
   if (controller) {
     timeout_.scheduleTimeout(&drainTimeout_,
                              controller->getGracefulShutdownTimeout());
   }
   notifyPendingShutdown();
 }

void proxygen::HTTPSession::removeWaitingForReplaySafety ( ReplaySafetyCallback * callback )

inlineoverrideprivatenoexcept

Remove a ReplaySafetyCallback that had been waiting for replay safety (eg if a transaction waiting for replay safety is canceled).

Definition at line 813 of file HTTPSession.h.

References waitingForReplaySafety_.

                                                         {
     waitingForReplaySafety_.remove(callback);
   }

void proxygen::HTTPSession::rescheduleLoopCallbacks ( )

inlineprotected

Definition at line 650 of file HTTPSession.h.

References folly::EventBase::LoopCallback::isLoopCallbackScheduled(), shutdownTransportCb_, and sock_.

Referenced by proxygen::HTTPUpstreamSession::attachThreadLocals().

                                  {
     if (!isLoopCallbackScheduled()) {
       sock_->getEventBase()->runInLoop(this);
     }
 
     if (shutdownTransportCb_ &&
         !shutdownTransportCb_->isLoopCallbackScheduled()) {
       sock_->getEventBase()->runInLoop(shutdownTransportCb_.get(), true);
     }
   }

void proxygen::HTTPSession::resumeIngress ( HTTPTransaction * txn )

overrideprotectedvirtualnoexcept

References bodyBytesPerWriteBuf_, bytesScheduled_, checkForShutdown(), folly::IOBuf::computeChainDataLength(), connFlowControl_, proxygen::FlowControlFilter::getAvailableSend(), proxygen::HTTPSession::WriteSegment::getFlags(), getNextToSend(), hasMoreWrites(), i, inLoopCallback_, invokeOnAllTransactions(), proxygen::HTTPSessionBase::isPrioritySampled(), folly::HHWheelTimer::Callback::isScheduled(), folly::makeGuard(), folly::gen::move, numActiveWrites_, proxygen::HTTP2PriorityQueue::numPendingEgress(), pendingWrites_, pendingWriteSizeDelta_, processReadData(), readsUnpaused(), proxygen::WheelTimerInstance::scheduleTimeout(), scheduleWrite(), proxygen::HTTPSession::WriteSegment::setCork(), proxygen::HTTPSession::WriteSegment::setEOR(), sock_, timeout_, txnEgressQueue_, uint32_t, uint64_t, proxygen::HTTPTransaction::updateContentionsCount(), proxygen::HTTPTransaction::updateSessionBytesSheduled(), updateWriteBufSize(), updateWriteCount(), fizz::detail::writeBuf(), proxygen::HTTPSession::WriteSegment::WriteSegment(), writesShutdown(), and writeTimeout_.

Definition at line 1519 of file HTTPSession.cpp.

References findTransaction(), liveTransactions_, and resumeReads().

Referenced by detach(), and numIncomingStreams().

                                                              {
   VLOG(4) << *this << " resuming streamID=" << txn->getID() <<
       ", liveTransactions_ was " << liveTransactions_;
   ++liveTransactions_;
   auto exTxns = txn->getExTransactions();
   for (auto it = exTxns.begin(); it != exTxns.end(); ++it) {
     auto exTxn = findTransaction(*it);
     if (exTxn) {
       exTxn->resumeIngress();
     }
   }
 
   if (liveTransactions_ == 1) {
     resumeReads();
   }
 }

void proxygen::HTTPSession::resumeReads ( )

protected

Unpause reading from the transport.

Note: If any codec callbacks arrived while reads were paused, they will be processed before network reads resume.

Definition at line 2780 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPSessionBase::ingressLimitExceeded(), readsPaused(), resumeReadsImpl(), and proxygen::HTTPCodec::supportsParallelRequests().

Referenced by detach(), notifyIngressBodyProcessed(), resumeIngress(), sessionByteOffset(), and startNow().

                          {
   if (!readsPaused() ||
       (codec_->supportsParallelRequests() &&
        ingressLimitExceeded())) {
     return;
   }
   resumeReadsImpl();
 }

void proxygen::HTTPSession::resumeReadsImpl ( )

protected

Definition at line 2789 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, folly::EventBase::LoopCallback::isLoopCallbackScheduled(), reads_, wangle::ManagedConnection::resetTimeout(), proxygen::HTTPCodec::setParserPaused(), and sock_.

Referenced by proxygen::HTTPUpstreamSession::attachThreadLocals(), invokeOnAllTransactions(), and resumeReads().

                                   {
   VLOG(4) << *this << ": resuming reads";
   resetTimeout();
   reads_ = SocketState::UNPAUSED;
   codec_->setParserPaused(false);
   if (!isLoopCallbackScheduled()) {
     sock_->getEventBase()->runInLoop(this);
   }
 }

void proxygen::HTTPSession::resumeTransactions ( )

protected

Definition at line 2850 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::egressLimitExceeded(), g(), inResume_, invokeOnAllTransactions(), proxygen::HTTP2PriorityQueue::iterateBFS(), proxygen::HTTPTransaction::pauseEgress(), pendingPause_, transactions_, and txnEgressQueue_.

Referenced by invokeOnAllTransactions(), and updateWriteBufSize().

                                      {
   CHECK(!inResume_);
   inResume_ = true;
   DestructorGuard g(this);
   auto resumeFn = [] (HTTP2PriorityQueue&, HTTPCodec::StreamID,
                       HTTPTransaction *txn, double) {
     if (txn) {
       txn->resumeEgress();
     }
     return false;
   };
   auto stopFn = [this] {
     return (transactions_.empty() || egressLimitExceeded());
   };
 
   txnEgressQueue_.iterateBFS(resumeFn, stopFn, true /* all */);
   inResume_ = false;
   if (pendingPause_) {
     VLOG(3) << "Pausing txn egress for " << *this;
     pendingPause_ = false;
     invokeOnAllTransactions(&HTTPTransaction::pauseEgress);
   }
 }

void proxygen::HTTPSession::runLoopCallback ( )

overrideprotectedvirtualnoexcept

Implements folly::EventBase::LoopCallback.

Definition at line 2137 of file HTTPSession.cpp.

Referenced by isDraining(), and onWriteSuccess().

                                       {
   // We schedule this callback to run at the end of an event
   // loop iteration if either of two conditions has happened:
   //   * The session has generated some egress data (see scheduleWrite())
   //   * Reads have become unpaused (see resumeReads())
   DestructorGuard dg(this);
   inLoopCallback_ = true;
   auto scopeg = folly::makeGuard([this] {
       inLoopCallback_ = false;
       // This ScopeGuard needs to be under the above DestructorGuard
       if (pendingWriteSizeDelta_) {
         updateWriteBufSize(0);
       }
       checkForShutdown();
     });
   VLOG(5) << *this << " in loop callback";
 
   for (uint32_t i = 0; i < kMaxWritesPerLoop; ++i) {
     bodyBytesPerWriteBuf_ = 0;
     if (isPrioritySampled()) {
       invokeOnAllTransactions(
         &HTTPTransaction::updateContentionsCount,
         txnEgressQueue_.numPendingEgress());
     }
 
     bool cork = true;
     bool eom = false;
     unique_ptr<IOBuf> writeBuf = getNextToSend(&cork, &eom);
 
     if (!writeBuf) {
       break;
     }
     uint64_t len = writeBuf->computeChainDataLength();
     VLOG(11) << *this
              << " bytes of egress to be written: " << len
              << " cork:" << cork << " eom:" << eom;
     if (len == 0) {
       checkForShutdown();
       return;
     }
 
     if (isPrioritySampled()) {
       invokeOnAllTransactions(
         &HTTPTransaction::updateSessionBytesSheduled,
         bodyBytesPerWriteBuf_);
     }
 
     WriteSegment* segment = new WriteSegment(this, len);
     segment->setCork(cork);
     segment->setEOR(eom);
 
     pendingWrites_.push_back(*segment);
     if (!writeTimeout_.isScheduled()) {
       // Any performance concern here?
       timeout_.scheduleTimeout(&writeTimeout_);
     }
     numActiveWrites_++;
     VLOG(4) << *this << " writing " << len << ", activeWrites="
              << numActiveWrites_ << " cork=" << cork << " eom=" << eom;
     bytesScheduled_ += len;
     sock_->writeChain(segment, std::move(writeBuf), segment->getFlags());
     if (numActiveWrites_ > 0) {
       updateWriteCount();
       pendingWriteSizeDelta_ += len;
       // updateWriteBufSize called in scope guard
       break;
     }
     // writeChain can result in a writeError and trigger the shutdown code path
   }
   if (numActiveWrites_ == 0 && !writesShutdown() && hasMoreWrites() &&
       (!connFlowControl_ || connFlowControl_->getAvailableSend())) {
     scheduleWrite();
   }
 
   if (readsUnpaused()) {
     processReadData();
 
     // Install the read callback if necessary
     if (readsUnpaused() && !sock_->getReadCallback()) {
       sock_->setReadCB(this);
     }
   }
   // checkForShutdown is now in ScopeGuard
 }

void proxygen::HTTPSession::scheduleWrite ( )

protected

Schedule a write to occur at the end of this event loop.

Definition at line 2223 of file HTTPSession.cpp.

References proxygen::HTTP2PriorityQueue::empty(), folly::IOBufQueue::front(), folly::EventBase::LoopCallback::isLoopCallbackScheduled(), sock_, txnEgressQueue_, and writeBuf_.

Referenced by closeWhenIdle(), drainImpl(), isDraining(), notifyIngressBodyProcessed(), notifyPendingEgress(), onBody(), onCertificateRequest(), onConnectionSendWindowOpen(), proxygen::HTTPUpstreamSession::onNativeProtocolUpgrade(), onNativeProtocolUpgradeImpl(), onNewTransactionParseError(), onPingRequest(), onSessionParseError(), onSettings(), runLoopCallback(), sendAbort(), sendCertificateRequest(), sendChunkHeader(), sendChunkTerminator(), sendHeaders(), sendPing(), sendPriorityImpl(), sendSettings(), sendWindowUpdate(), shutdownTransport(), proxygen::HTTPUpstreamSession::startNow(), and startNow().

                            {
   // Do all the network writes for this connection in one batch at
   // the end of the current event loop iteration.  Writing in a
   // batch helps us packetize the network traffic more efficiently,
   // as well as saving a few system calls.
   if (!isLoopCallbackScheduled() &&
       (writeBuf_.front() || !txnEgressQueue_.empty())) {
     VLOG(5) << *this << " scheduling write callback";
     sock_->getEventBase()->runInLoop(this);
   }
 }

size_t proxygen::HTTPSession::sendAbort	(	HTTPTransaction *	txn,
		ErrorCode	statusCode
	)

overrideprotectedvirtualnoexcept

Definition at line 1783 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::generateRstStream(), proxygen::HTTPCodec::isReusable(), onEgressMessageFinished(), scheduleWrite(), proxygen::HTTPSessionBase::setCloseReason(), statusCode, proxygen::TRANSACTION_ABORT, and writeBuf_.

Referenced by numIncomingStreams().

                                                              {
   // Ask the codec to generate an abort indicator for the transaction.
   // Depending on the protocol, this may be a no-op.
   // Schedule a network write to send out whatever egress we might
   // have queued up.
   VLOG(4) << *this << " sending abort for streamID=" << txn->getID();
   // drain this transaction's writeBuf instead of flushing it
   // then enqueue the abort directly into the Session buffer,
   // hence with max priority.
   size_t encodedSize = codec_->generateRstStream(writeBuf_,
                                                  txn->getID(),
                                                  statusCode);
 
   if (!codec_->isReusable()) {
     // HTTP 1x codec does not support per stream abort so this will
     // render the codec not reusable
     setCloseReason(ConnectionCloseReason::TRANSACTION_ABORT);
   }
 
   scheduleWrite();
 
   // If the codec wasn't able to write a L7 message for the abort, then
   // fall back to closing the transport with a TCP level RST
   onEgressMessageFinished(txn, !encodedSize);
   return encodedSize;
 }

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

overrideprotectedvirtualnoexcept

Definition at line 1667 of file HTTPSession.cpp.

References bodyBytesPerWriteBuf_, byteEventTracker_, proxygen::HTTPSessionBase::codec_, commonEom(), proxygen::HTTPCodec::generateBody(), inLoopCallback_, folly::gen::move, proxygen::HTTPCodec::NoPadding, pendingWriteSizeDelta_, sessionByteOffset(), uint64_t, and writeBuf_.

Referenced by numIncomingStreams().

                                                           {
   uint64_t offset = sessionByteOffset();
   size_t bodyLen = body ? body->computeChainDataLength(): 0;
   size_t encodedSize = codec_->generateBody(writeBuf_,
                                             txn->getID(),
                                             std::move(body),
                                             HTTPCodec::NoPadding,
                                             includeEOM);
   CHECK(inLoopCallback_);
   pendingWriteSizeDelta_ -= bodyLen;
   bodyBytesPerWriteBuf_ += bodyLen;
   if (encodedSize > 0 && !txn->testAndSetFirstByteSent() && byteEventTracker_) {
     byteEventTracker_->addFirstBodyByteEvent(offset, txn);
   }
 
   if (trackLastByteFlushed && encodedSize > 0 && byteEventTracker_) {
     byteEventTracker_->addTrackedByteEvent(txn, offset + encodedSize);
   }
 
   if (includeEOM) {
     VLOG(5) << *this << " sending EOM in body for streamID=" << txn->getID();
     commonEom(txn, encodedSize, true);
   }
   return encodedSize;
 }

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

overridevirtual

Send a CERTIFICATE_REQUEST frame. If the underlying protocol doesn't support secondary authentication, this is a no-op and 0 is returned.

Reimplemented from proxygen::HTTPSessionBase.

Definition at line 1829 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::generateCertificateRequest(), proxygen::HTTPCodec::getEgressSettings(), proxygen::HTTPCodec::getIngressSettings(), folly::gen::move, scheduleWrite(), secondAuthManager_, proxygen::SETTINGS_HTTP_CERT_AUTH, and writeBuf_.

Referenced by getSetupTransportInfo().

                                          {
   // Check if both sending and receiving peer have advertised valid
   // SETTINGS_HTTP_CERT_AUTH setting. Otherwise, the frames for secondary
   // authentication should not be sent.
   auto ingressSettings = codec_->getIngressSettings();
   auto egressSettings = codec_->getEgressSettings();
   if (ingressSettings && egressSettings) {
     if (ingressSettings->getSetting(SettingsId::SETTINGS_HTTP_CERT_AUTH, 0) ==
             0 ||
         egressSettings->getSetting(SettingsId::SETTINGS_HTTP_CERT_AUTH, 0) ==
             0) {
       VLOG(4) << "Secondary certificate authentication is not supported.";
       return 0;
     }
   }
   auto authRequest = secondAuthManager_->createAuthRequest(
       std::move(certificateRequestContext), std::move(extensions));
   auto encodedSize = codec_->generateCertificateRequest(
       writeBuf_, authRequest.first, std::move(authRequest.second));
   if (encodedSize > 0) {
     scheduleWrite();
   } else {
     VLOG(4) << "Failed to generate CERTIFICATE_REQUEST frame.";
   }
   return encodedSize;
 }

size_t proxygen::HTTPSession::sendChunkHeader	(	HTTPTransaction *	txn,
		size_t	length
	)

overrideprotectedvirtualnoexcept

Definition at line 1696 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::generateChunkHeader(), scheduleWrite(), and writeBuf_.

Referenced by numIncomingStreams().

                             {
   size_t encodedSize = codec_->generateChunkHeader(writeBuf_,
                                                    txn->getID(),
                                                    length);
   scheduleWrite();
   return encodedSize;
 }

size_t proxygen::HTTPSession::sendChunkTerminator ( HTTPTransaction * txn )

overrideprotectedvirtualnoexcept

Definition at line 1705 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::generateChunkTerminator(), scheduleWrite(), and writeBuf_.

Referenced by numIncomingStreams().

                                    {
   size_t encodedSize = codec_->generateChunkTerminator(writeBuf_,
                                                        txn->getID());
   scheduleWrite();
   return encodedSize;
 }

size_t proxygen::HTTPSession::sendEOM	(	HTTPTransaction *	txn,
		const HTTPHeaders *	trailers
	)

overrideprotectedvirtualnoexcept

Definition at line 1761 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, commonEom(), proxygen::HTTPCodec::generateEOM(), proxygen::HTTPCodec::generateTrailers(), proxygen::HTTPCodec::getProtocol(), proxygen::isHTTP2CodecProtocol(), and writeBuf_.

Referenced by numIncomingStreams().

                                                                   {
 
   VLOG(4) << *this << " sending EOM for streamID=" << txn->getID()
           << " trailers=" << (trailers ? "yes" : "no");
 
   size_t encodedSize = 0;
   if (trailers) {
     encodedSize = codec_->generateTrailers(writeBuf_, txn->getID(), *trailers);
   }
 
   // Don't send EOM for HTTP2, when trailers sent.
   // sendTrailers already flagged end of stream.
   bool http2Trailers = trailers && isHTTP2CodecProtocol(codec_->getProtocol());
   if (!http2Trailers) {
     encodedSize += codec_->generateEOM(writeBuf_, txn->getID());
   }
 
   commonEom(txn, encodedSize, false);
   return encodedSize;
 }

void proxygen::HTTPSession::sendHeaders	(	HTTPTransaction *	txn,
		const HTTPMessage &	headers,
		HTTPHeaderSize *	size,
		bool	includeEOM
	)

overrideprotectedvirtualnoexcept

Definition at line 1576 of file HTTPSession.cpp.

References folly::IOBufQueue::append(), byteEventTracker_, proxygen::HTTPSessionBase::codec_, commonEom(), drainImpl(), proxygen::HTTPCodec::generateExHeader(), proxygen::HTTPCodec::generateHeader(), proxygen::HTTPCodec::generatePushPromise(), getHTTP2PrioritiesEnabled(), getMessagePriority(), incrementOutgoingStreams(), isDownstream(), proxygen::HTTPCodec::isReusable(), isUpstream(), folly::IOBufQueue::move(), folly::gen::move, onHeadersSent(), scheduleWrite(), sessionByteOffset(), shouldShutdown(), folly::size(), started_, uint64_t, fizz::detail::writeBuf(), and writeBuf_.

Referenced by numIncomingStreams().

                                                         {
   CHECK(started_);
   unique_ptr<IOBuf> goawayBuf;
   if (shouldShutdown()) {
     // For HTTP/1.1, add Connection: close
     // For SPDY, save the goaway for AFTER the request
     auto writeBuf = writeBuf_.move();
     drainImpl();
     goawayBuf = writeBuf_.move();
     writeBuf_.append(std::move(writeBuf));
   }
   if (isUpstream() || (txn->isPushed() && headers.isRequest())) {
     // upstream picks priority
     if (getHTTP2PrioritiesEnabled()) {
       auto pri = getMessagePriority(&headers);
       txn->onPriorityUpdate(pri);
     }
   }
 
   const bool wasReusable = codec_->isReusable();
   const uint64_t oldOffset = sessionByteOffset();
   auto exAttributes = txn->getExAttributes();
   auto assocStream = txn->getAssocTxnId();
   if (exAttributes) {
     codec_->generateExHeader(writeBuf_,
                              txn->getID(),
                              headers,
                              *exAttributes,
                              includeEOM,
                              size);
   } else if (headers.isRequest() && assocStream) {
     // Only PUSH_PROMISE (not push response) has an associated stream
     codec_->generatePushPromise(writeBuf_,
                                 txn->getID(),
                                 headers,
                                 *assocStream,
                                 includeEOM,
                                 size);
   } else {
     codec_->generateHeader(writeBuf_,
                            txn->getID(),
                            headers,
                            includeEOM,
                            size);
   }
   const uint64_t newOffset = sessionByteOffset();
 
   // for push response count towards the MAX_CONCURRENT_STREAMS limit
   if (isDownstream() && headers.isResponse() && txn->isPushed()) {
     incrementOutgoingStreams();
   }
 
   // For all upstream headers, addFirstHeaderByteEvent should be added
   // For all downstream, only response headers need addFirstHeaderByteEvent
   bool shouldAddFirstHeaderByteEvent = isUpstream() ||
                                        (isDownstream() && headers.isResponse());
   if (shouldAddFirstHeaderByteEvent && newOffset > oldOffset &&
       !txn->testAndSetFirstHeaderByteSent() && byteEventTracker_) {
     byteEventTracker_->addFirstHeaderByteEvent(newOffset, txn);
   }
 
   if (size) {
     VLOG(4) << *this << " sending headers, size=" << size->compressed
             << ", uncompressedSize=" << size->uncompressed;
   }
   if (goawayBuf) {
     VLOG(4) << *this << " moved GOAWAY to end of writeBuf";
     writeBuf_.append(std::move(goawayBuf));
   }
   if (includeEOM) {
     commonEom(txn, 0, true);
   }
   scheduleWrite();
   onHeadersSent(headers, wasReusable);
 }

size_t proxygen::HTTPSession::sendPing ( )

overridevirtual

Causes a ping to be sent on the session. If the underlying protocol doesn't support pings, this will return 0. Otherwise, it will return the number of bytes written on the transport to send the ping.

Implements proxygen::HTTPSessionBase.

Definition at line 2505 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::generatePingRequest(), scheduleWrite(), and writeBuf_.

Referenced by getSetupTransportInfo().

                              {
   const size_t bytes = codec_->generatePingRequest(writeBuf_);
   if (bytes) {
     scheduleWrite();
   }
   return bytes;
 }

HTTPCodec::StreamID proxygen::HTTPSession::sendPriority ( http2::PriorityUpdate pri )

overridevirtual

Sends a priority message on this session. If the underlying protocol doesn't support priority, this is a no-op. A new stream identifier will be selected and returned.

Implements proxygen::HTTPPriorityMapFactoryProvider.

Definition at line 2513 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::createStream(), and proxygen::HTTPCodec::supportsParallelRequests().

Referenced by getSetupTransportInfo(), and numIncomingStreams().

                                                                    {
   if (!codec_->supportsParallelRequests()) {
     // For HTTP/1.1, don't call createStream()
     return 0;
   }
   auto id = codec_->createStream();
   sendPriority(id, pri);
   return id;
 }

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

overridevirtual

As above, but updates an existing priority node. Do not use for real nodes, prefer HTTPTransaction::changePriority.

Implements proxygen::HTTPSessionBase.

Definition at line 2523 of file HTTPSession.cpp.

References proxygen::HTTP2PriorityQueue::addOrUpdatePriorityNode(), sendPriorityImpl(), and txnEgressQueue_.

                                                           {
   auto res = sendPriorityImpl(id, pri);
   txnEgressQueue_.addOrUpdatePriorityNode(id, pri);
   return res;
 }

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

overrideprotectedvirtualnoexcept

Definition at line 1811 of file HTTPSession.cpp.

References sendPriorityImpl().

                                                                           {
   return sendPriorityImpl(txn->getID(), pri);
 }

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

protected

Sends a priority message on this session. If the underlying protocol doesn't support priority, this is a no-op. Returns the number of bytes written on the transport

Definition at line 2531 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::http2::PriorityUpdate::exclusive, proxygen::HTTPCodec::generatePriority(), std::tr1::make_tuple(), scheduleWrite(), proxygen::http2::PriorityUpdate::streamDependency, proxygen::http2::PriorityUpdate::weight, and writeBuf_.

Referenced by onHeadersSent(), and sendPriority().

                                                               {
   CHECK_NE(id, 0);
   const size_t bytes = codec_->generatePriority(
     writeBuf_, id, std::make_tuple(pri.streamDependency,
                                    pri.exclusive,
                                    pri.weight));
   if (bytes) {
     scheduleWrite();
   }
   return bytes;
 }

size_t proxygen::HTTPSession::sendSettings ( )

overridevirtual

Send a settings frame

Implements proxygen::HTTPSessionBase.

Definition at line 1495 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::generateSettings(), scheduleWrite(), folly::size(), and writeBuf_.

Referenced by getSetupTransportInfo(), and onNativeProtocolUpgradeImpl().

                                  {
   size_t size = codec_->generateSettings(writeBuf_);
   scheduleWrite();
   return size;
 }

size_t proxygen::HTTPSession::sendWindowUpdate	(	HTTPTransaction *	txn,
		uint32_t	bytes
	)

overrideprotectedvirtualnoexcept

Definition at line 1976 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::generateWindowUpdate(), scheduleWrite(), and writeBuf_.

Referenced by numIncomingStreams().

                                                        {
   size_t sent = codec_->generateWindowUpdate(writeBuf_, txn->getID(), bytes);
   if (sent) {
     scheduleWrite();
   }
   return sent;
 }

uint64_t proxygen::HTTPSession::sessionByteOffset ( )

inlineprotected

Tells us what would be the offset of the next byte to be enqueued within the whole session.

Definition at line 511 of file HTTPSession.h.

References bytesScheduled_, folly::IOBufQueue::chainLength(), checkForShutdown(), createTransaction(), proxygen::http2::DefaultPriority, findTransaction(), hasMoreWrites(), immediateShutdown(), onNewTransactionParseError(), onSessionParseError(), onWriteCompleted(), onWriteError(), onWriteSuccess(), pauseReads(), resumeReads(), uint64_t, and writeBuf_.

Referenced by commonEom(), sendBody(), and sendHeaders().

                                       {
     return bytesScheduled_ + writeBuf_.chainLength();
   }

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

Definition at line 317 of file HTTPSession.cpp.

References byteEventTracker_, folly::gen::move, and proxygen::HTTPSessionBase::sessionStats_.

Referenced by getByteEventTracker(), and TEST().

                                                     {
   if (byteEventTracker && byteEventTracker_) {
     byteEventTracker->absorb(std::move(*byteEventTracker_));
   }
   byteEventTracker_ = byteEventTracker;
   if (byteEventTracker_) {
     byteEventTracker_->setCallback(this);
     byteEventTracker_->setTTLBAStats(sessionStats_);
   }
 }

void proxygen::HTTPSession::setEgressBytesLimit ( uint64_t bytesLimit )

Set the maximum number of bytes allowed to be egressed in the session before cutting it off

Definition at line 373 of file HTTPSession.cpp.

References egressBytesLimit_, and started_.

Referenced by getSetupTransportInfo().

                                                          {
   CHECK(!started_);
   egressBytesLimit_ = bytesLimit;
 }

void proxygen::HTTPSession::setEgressSettings ( const SettingsList & inSettings )

overridevirtual

Set outgoing settings for this session

Implements proxygen::HTTPSessionBase.

Definition at line 351 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::getEgressSettings(), proxygen::HTTPSettings::setSetting(), settings, and started_.

Referenced by getByteEventTracker(), and proxygen::HTTPSessionAcceptor::onNewConnection().

                                                                   {
   VLOG_IF(4, started_) << "Must flush egress settings to peer";
   HTTPSettings* settings = codec_->getEgressSettings();
   if (settings) {
     for (const auto& setting: inSettings) {
       settings->setSetting(setting.id, setting.value);
     }
   }
 }

void proxygen::HTTPSession::setFlowControl	(	size_t	initialReceiveWindow,
		size_t	receiveStreamWindowSize,
		size_t	receiveSessionWindowSize
	)

overridevirtual

Set flow control properties on the session.

Parameters

initialReceiveWindow	size of initial receive window for all ingress streams; set via the initial SETTINGS frame
receiveStreamWindowSize	per-stream receive window for NEW streams; sent via a WINDOW_UPDATE frame
receiveSessionWindowSize	per-session receive window; sent via a WINDOW_UPDATE frame

Implements proxygen::HTTPSessionBase.

Definition at line 336 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::getEgressSettings(), proxygen::INITIAL_WINDOW_SIZE, initialReceiveWindow_, receiveSessionWindowSize_, receiveStreamWindowSize_, proxygen::HTTPSessionBase::setReadBufferLimit(), proxygen::HTTPSettings::setSetting(), settings, and started_.

Referenced by HTTPUpstreamTest< SPDY3CodecPair >::commonSetUp(), CurlService::CurlClient::connectSuccess(), getByteEventTracker(), and proxygen::HTTPSessionAcceptor::onNewConnection().

                                                                   {
   CHECK(!started_);
   initialReceiveWindow_ = initialReceiveWindow;
   receiveStreamWindowSize_ = receiveStreamWindowSize;
   receiveSessionWindowSize_ = receiveSessionWindowSize;
   HTTPSessionBase::setReadBufferLimit(receiveSessionWindowSize);
   HTTPSettings* settings = codec_->getEgressSettings();
   if (settings) {
     settings->setSetting(SettingsId::INITIAL_WINDOW_SIZE,
                          initialReceiveWindow_);
   }
 }

void proxygen::HTTPSession::setHeaderCodecStats ( HeaderCodec::Stats * stats )

inlineoverridevirtual

Implements proxygen::HTTPSessionBase.

Definition at line 204 of file HTTPSession.h.

References proxygen::HTTPSessionBase::codec_, and proxygen::HTTPCodec::setHeaderCodecStats().

                                                              {
     codec_->setHeaderCodecStats(stats);
   }

void proxygen::HTTPSession::setHTTP2PrioritiesEnabled ( bool enabled )

inlineoverridevirtual

References proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::addFilters(), proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::call(), proxygen::HTTPSessionBase::codec_, connFlowControl_, proxygen::HTTPCodec::generateConnectionPreface(), getCertAuthSettingVal(), proxygen::HTTPCodec::getEgressSettings(), isDownstream(), proxygen::MAX_CONCURRENT_STREAMS, maxConcurrentIncomingStreams_, maxConcurrentOutgoingStreamsRemote_, secondAuthManager_, proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::setCallback(), proxygen::HTTPSettings::setSetting(), settings, proxygen::SETTINGS_HTTP_CERT_AUTH, proxygen::HTTPCodec::supportsParallelRequests(), proxygen::HTTPCodec::supportsSessionFlowControl(), uint32_t, and writeBuf_.

Definition at line 118 of file HTTPSession.h.

References proxygen::HTTPSessionBase::setHTTP2PrioritiesEnabled().

Referenced by proxygen::HTTPSessionAcceptor::onNewConnection().

                                                         {
     HTTPSessionBase::setHTTP2PrioritiesEnabled(enabled);
   }

void proxygen::HTTPSession::setMaxConcurrentIncomingStreams ( uint32_t num )

overridevirtual

Set the maximum number of transactions the remote can open at once.

Implements proxygen::HTTPSessionBase.

Definition at line 361 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, proxygen::HTTPCodec::getEgressSettings(), proxygen::MAX_CONCURRENT_STREAMS, maxConcurrentIncomingStreams_, proxygen::HTTPSettings::setSetting(), settings, started_, and proxygen::HTTPCodec::supportsParallelRequests().

Referenced by getSetupTransportInfo(), and proxygen::HTTPSessionAcceptor::onNewConnection().

                                                               {
   CHECK(!started_);
   if (codec_->supportsParallelRequests()) {
     maxConcurrentIncomingStreams_ = num;
     HTTPSettings* settings = codec_->getEgressSettings();
     if (settings) {
       settings->setSetting(SettingsId::MAX_CONCURRENT_STREAMS,
                            maxConcurrentIncomingStreams_);
     }
   }
 }

void proxygen::HTTPSession::setNewTransactionPauseState ( HTTPCodec::StreamID streamID )

protected

Definition at line 722 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::egressLimitExceeded(), findTransaction(), and numActiveWrites_.

Referenced by newExTransaction(), newPushedTransaction(), proxygen::HTTPUpstreamSession::newTransaction(), onHeadersSent(), and proxygen::HTTPDownstreamSession::setupOnHeadersComplete().

                                                                    {
   if (!egressLimitExceeded()) {
     return;
   }
 
   auto txn = findTransaction(streamID);
   if (txn) {
     // If writes are paused, start this txn off in the egress paused state
     VLOG(4) << *this << " starting streamID=" << txn->getID()
             << " egress paused, numActiveWrites_=" << numActiveWrites_;
     txn->pauseEgress();
   }
 }

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

Attach a SecondaryAuthManager to this session to control secondary certificate authentication in HTTP/2.

Definition at line 1816 of file HTTPSession.cpp.

References folly::gen::move, and secondAuthManager_.

Referenced by connCloseByRemote().

                                                            {
   secondAuthManager_ = std::move(secondAuthManager);
 }

void proxygen::HTTPSession::setSessionStats ( HTTPSessionStats * stats )

overridevirtual

Reimplemented from proxygen::HTTPSessionBase.

Definition at line 329 of file HTTPSession.cpp.

References byteEventTracker_, and proxygen::HTTPSessionBase::setSessionStats().

Referenced by proxygen::HTTPUpstreamSession::attachThreadLocals(), proxygen::HTTPUpstreamSession::detachThreadLocals(), getByteEventTracker(), and proxygen::HTTPSessionAcceptor::onNewConnection().

                                                          {
   HTTPSessionBase::setSessionStats(stats);
   if (byteEventTracker_) {
     byteEventTracker_->setTTLBAStats(stats);
   }
 }

void proxygen::HTTPSession::setupCodec ( )

private

Definition at line 243 of file HTTPSession.cpp.

Referenced by getMaxConcurrentOutgoingStreamsRemote(), onNativeProtocolUpgradeImpl(), and proxygen::HTTPSession::WriteSegment::writeErr().

                              {
   if (!codec_->supportsParallelRequests()) {
     // until we support upstream pipelining
     maxConcurrentIncomingStreams_ = 1;
     maxConcurrentOutgoingStreamsRemote_ = isDownstream() ? 0 : 1;
   }
 
   // If a secondary authentication manager is configured for this session, set
   // the SETTINGS_HTTP_CERT_AUTH to indicate support for HTTP-layer certificate
   // authentication.
   uint32_t certAuthSettingVal = 0;
   if (secondAuthManager_) {
     certAuthSettingVal = getCertAuthSettingVal();
   }
   HTTPSettings* settings = codec_->getEgressSettings();
   if (settings) {
     settings->setSetting(SettingsId::MAX_CONCURRENT_STREAMS,
                          maxConcurrentIncomingStreams_);
     if (certAuthSettingVal != 0) {
       settings->setSetting(SettingsId::SETTINGS_HTTP_CERT_AUTH,
                            certAuthSettingVal);
     }
   }
   codec_->generateConnectionPreface(writeBuf_);
 
   if (codec_->supportsSessionFlowControl() && !connFlowControl_) {
     connFlowControl_ = new FlowControlFilter(*this, writeBuf_, codec_.call());
     codec_.addFilters(std::unique_ptr<FlowControlFilter>(connFlowControl_));
     // if we really support switching from spdy <-> h2, we need to update
     // existing flow control filter
   }
 
   codec_.setCallback(this);
 }

virtual void proxygen::HTTPSession::setupOnHeadersComplete	(	HTTPTransaction *	txn,
		HTTPMessage *	msg
	)

protectedpure virtual

Called by onHeadersComplete(). This function allows downstream and upstream to do any setup (like preparing a handler) when headers are first received from the remote side on a given transaction.

Implemented in proxygen::HTTPUpstreamSession, and proxygen::HTTPDownstreamSession.

Referenced by connCloseByRemote(), and onHeadersComplete().

bool proxygen::HTTPSession::shouldShutdown ( ) const

protected

Returns true iff this session should shutdown at this time. Default behavior is to not shutdown.

Definition at line 2497 of file HTTPSession.cpp.

References allTransactionsStarted(), proxygen::HTTPSessionBase::codec_, draining_, proxygen::HTTPCodec::isReusable(), isUpstream(), and proxygen::HTTPCodec::supportsParallelRequests().

Referenced by detach(), invokeOnAllTransactions(), and sendHeaders().

                                        {
   return draining_ &&
     allTransactionsStarted() &&
     (!codec_->supportsParallelRequests() ||
      isUpstream() ||
      !codec_->isReusable());
 }

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

protected

Start closing the socket.

Parameters

shutdownReads	Whether to close the read side of the socket. All transactions which are not ingress complete will receive an error.
shutdownWrites	Whether to close the write side of the socket. All transactions which are not egress complete will receive an error.
errorMsg	additional error information to pass to each transaction

Definition at line 2283 of file HTTPSession.cpp.

References byteEventTracker_, checkForShutdown(), proxygen::HTTPCodec::closeOnEgressComplete(), proxygen::HTTPSessionBase::codec_, folly::SocketAddress::describe(), proxygen::HTTPException::EGRESS, folly::pushmi::operators::error(), flowControlTimeout_, proxygen::HTTPCodec::generateGoaway(), proxygen::HTTPSessionBase::getConnectionCloseReason(), proxygen::getErrorString(), proxygen::HTTPCodec::getLastIncomingStreamID(), getPeerAddress(), folly::gen::guard(), hasMoreWrites(), proxygen::HTTPSessionBase::infoCallback_, proxygen::HTTPException::INGRESS, proxygen::HTTPException::INGRESS_AND_EGRESS, invokeOnAllTransactions(), proxygen::IO_WRITE_ERROR, folly::HHWheelTimer::Callback::isScheduled(), proxygen::kErrorConnectionReset, proxygen::kErrorEOF, proxygen::kErrorSSL, proxygen::kErrorTimeout, proxygen::kErrorWrite, proxygen::NO_ERROR, proxygen::HTTPTransaction::onError(), proxygen::HTTPSessionBase::InfoCallback::onIngressEOF(), proxygen::HTTPCodec::onIngressEOF(), proxygen::HTTPSessionBase::InfoCallback::onIngressError(), reads_, readsShutdown(), resetAfterDrainingWrites_, resetSocketOnShutdown_, scheduleWrite(), proxygen::HTTPSessionBase::setCloseReason(), proxygen::HTTPCodec::setParserPaused(), proxygen::Exception::setProxygenError(), proxygen::SHUTDOWN, sock_, wangle::TransportInfo::sslError, proxygen::TIMEOUT, transactions_, proxygen::HTTPSessionBase::transportInfo_, proxygen::UNKNOWN, writeBuf_, writes_, writesDraining_, and writesShutdown().

Referenced by detach(), drain(), dropConnection(), flowControlTimeoutExpired(), isDraining(), onDeleteAckEvent(), onEgressMessageFinished(), onError(), onMessageComplete(), onSessionParseError(), onWriteCompleted(), onWriteSuccess(), readEOF(), readErr(), and proxygen::HTTPSession::ShutdownTransportCallback::runLoopCallback().

                                                           {
   DestructorGuard guard(this);
 
   // shutdowns not accounted for, shouldn't see any
   setCloseReason(ConnectionCloseReason::UNKNOWN);
 
   VLOG(4) << "shutdown request for " << *this << ": reads="
           << shutdownReads << " (currently " << readsShutdown()
           << "), writes=" << shutdownWrites << " (currently "
           << writesShutdown() << ")";
 
   bool notifyEgressShutdown = false;
   bool notifyIngressShutdown = false;
 
   ProxygenError error;
   if (!transportInfo_.sslError.empty()) {
     error = kErrorSSL;
   } else if (sock_->error()) {
     VLOG(3) << "shutdown request for " << *this
       << " on bad socket. Shutting down writes too.";
     if (getConnectionCloseReason() == ConnectionCloseReason::IO_WRITE_ERROR) {
       error = kErrorWrite;
     } else {
       error = kErrorConnectionReset;
     }
     shutdownWrites = true;
   } else if (getConnectionCloseReason() == ConnectionCloseReason::TIMEOUT) {
     error = kErrorTimeout;
   } else {
     error = kErrorEOF;
   }
 
   if (shutdownReads && !shutdownWrites && flowControlTimeout_.isScheduled()) {
     // reads are dead and writes are blocked on a window update that will never
     // come.  shutdown writes too.
     VLOG(4) << *this << " Converting read shutdown to read/write due to"
       " flow control";
     shutdownWrites = true;
   }
 
   if (shutdownWrites && !writesShutdown()) {
     if (codec_->generateGoaway(writeBuf_,
                                codec_->getLastIncomingStreamID(),
                                ErrorCode::NO_ERROR)) {
       scheduleWrite();
     }
     if (!hasMoreWrites() &&
         (transactions_.empty() || codec_->closeOnEgressComplete())) {
       writes_ = SocketState::SHUTDOWN;
       if (byteEventTracker_) {
         byteEventTracker_->drainByteEvents();
       }
       if (resetAfterDrainingWrites_) {
         VLOG(4) << *this << " writes drained, sending RST";
         resetSocketOnShutdown_ = true;
         shutdownReads = true;
       } else {
         VLOG(4) << *this << " writes drained, closing";
         sock_->shutdownWriteNow();
       }
       notifyEgressShutdown = true;
     } else if (!writesDraining_) {
       writesDraining_ = true;
       notifyEgressShutdown = true;
     } // else writes are already draining; don't double notify
   }
 
   if (shutdownReads && !readsShutdown()) {
     notifyIngressShutdown = true;
     // TODO: send an RST if readBuf_ is non empty?
     sock_->setReadCB(nullptr);
     reads_ = SocketState::SHUTDOWN;
     if (!transactions_.empty() && error == kErrorConnectionReset) {
       if (infoCallback_ != nullptr) {
         infoCallback_->onIngressError(*this, error);
       }
     } else if (error == kErrorEOF) {
       // Report to the codec that the ingress stream has ended
       codec_->onIngressEOF();
       if (infoCallback_) {
         infoCallback_->onIngressEOF();
       }
     }
     // Once reads are shutdown the parser should stop processing
     codec_->setParserPaused(true);
   }
 
   if (notifyIngressShutdown || notifyEgressShutdown) {
     auto dir = (notifyIngressShutdown && notifyEgressShutdown)
                    ? HTTPException::Direction::INGRESS_AND_EGRESS
                    : (notifyIngressShutdown ? HTTPException::Direction::INGRESS
                                             : HTTPException::Direction::EGRESS);
     HTTPException ex(
         dir,
         folly::to<std::string>("Shutdown transport: ", getErrorString(error),
                                errorMsg.empty() ? "" : " ", errorMsg, ", ",
                                getPeerAddress().describe()));
     ex.setProxygenError(error);
     invokeOnAllTransactions(&HTTPTransaction::onError, ex);
   }
 
   // Close the socket only after the onError() callback on the txns
   // and handler has been detached.
   checkForShutdown();
 }

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

protected

Immediately close the socket in both directions, discarding any queued writes that haven't yet been transferred to the kernel, and send a RST to the client. All transactions receive onWriteError.

Parameters

errorCode	Error code sent with the onWriteError to transactions.
errorMsg	Error string included in the final error msg.

Definition at line 2391 of file HTTPSession.cpp.

References byteEventTracker_, folly::EventBase::LoopCallback::cancelLoopCallback(), folly::HHWheelTimer::Callback::cancelTimeout(), checkForShutdown(), destroy(), errorOnAllTransactions(), folly::gen::guard(), folly::EventBase::LoopCallback::isLoopCallbackScheduled(), folly::IOBufQueue::move(), numActiveWrites_, pendingWrites_, reads_, readsShutdown(), resetSocketOnShutdown_, proxygen::SHUTDOWN, sock_, writeBuf_, writes_, writesShutdown(), and writeTimeout_.

Referenced by dropConnection(), isDraining(), onWriteError(), and writeTimeoutExpired().

                                {
   DestructorGuard guard(this);
   VLOG(4) << "shutdownTransportWithReset";
 
   if (!readsShutdown()) {
     sock_->setReadCB(nullptr);
     reads_ = SocketState::SHUTDOWN;
   }
 
   if (!writesShutdown()) {
     writes_ = SocketState::SHUTDOWN;
     IOBuf::destroy(writeBuf_.move());
     while (!pendingWrites_.empty()) {
       pendingWrites_.front().detach();
       numActiveWrites_--;
     }
     VLOG(4) << *this << " cancel write timer";
     writeTimeout_.cancelTimeout();
     resetSocketOnShutdown_ = true;
   }
 
   errorOnAllTransactions(errorCode, errorMsg);
   // drainByteEvents() can call detach(txn), which can in turn call
   // shutdownTransport if we were already draining. To prevent double
   // calling onError() to the transactions, we call drainByteEvents()
   // after we've given the explicit error.
   if (byteEventTracker_) {
     byteEventTracker_->drainByteEvents();
   }
 
   // HTTPTransaction::onError could theoretically schedule more callbacks,
   // so do this last.
   if (isLoopCallbackScheduled()) {
     cancelLoopCallback();
   }
   // onError() callbacks or drainByteEvents() could result in txns detaching
   // due to CallbackGuards going out of scope. Close the socket only after
   // the txns are detached.
   checkForShutdown();
 }

void proxygen::HTTPSession::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.

Implements proxygen::HTTPSessionBase.

Reimplemented in proxygen::HTTPUpstreamSession.

Definition at line 297 of file HTTPSession.cpp.

References proxygen::HTTPSessionBase::codec_, connFlowControl_, draining_, proxygen::HTTPCodec::generateGoaway(), proxygen::HTTPCodec::generateSettings(), getGracefulGoawayAck(), proxygen::NO_ERROR, receiveSessionWindowSize_, resumeReads(), scheduleWrite(), proxygen::FlowControlFilter::setReceiveWindowSize(), started_, and writeBuf_.

Referenced by getSetupTransportInfo(), proxygen::HTTPDownstreamSession::startNow(), and proxygen::HTTPUpstreamSession::startNow().

                            {
   CHECK(!started_);
   started_ = true;
   codec_->generateSettings(writeBuf_);
   if (connFlowControl_) {
     connFlowControl_->setReceiveWindowSize(writeBuf_,
                                            receiveSessionWindowSize_);
   }
   // For HTTP/2 if we are currently draining it means we got notified to
   // shutdown before we sent a SETTINGS frame, so we defer sending a GOAWAY
   // util we've started and sent SETTINGS.
   if (draining_) {
     codec_->generateGoaway(writeBuf_,
                            getGracefulGoawayAck(),
                            ErrorCode::NO_ERROR);
   }
   scheduleWrite();
   resumeReads();
 }

void proxygen::HTTPSession::timeoutExpired ( )

inlineoverridevirtualnoexcept

timeoutExpired() is invoked when the timeout has expired.

Implements wangle::ManagedConnection.

Definition at line 190 of file HTTPSession.h.

References closeWhenIdle(), describe(), dropConnection(), dumpConnectionState(), getCurrentTransportInfoWithoutUpdate(), isBusy(), notifyPendingShutdown(), readTimeoutExpired(), and uint8_t.

                                           {
       readTimeoutExpired();
   }

void proxygen::HTTPSession::transactionTimeout ( HTTPTransaction * txn )

overrideprotectedvirtualnoexcept