proxygen: proxygen::HTTPParallelCodec Class Reference

#include <HTTPParallelCodec.h>

Inheritance diagram for proxygen::HTTPParallelCodec:

Public Member Functions
	HTTPParallelCodec (TransportDirection direction)

TransportDirection	getTransportDirection () const override

StreamID	createStream () override

bool	isBusy () const override

bool	supportsStreamFlowControl () const override

bool	supportsSessionFlowControl () const override

bool	supportsParallelRequests () const override

bool	closeOnEgressComplete () const override

void	setCallback (Callback *callback) override

void	setParserPaused (bool) override

void	onIngressEOF () override

bool	isReusable () const override

bool	isWaitingToDrain () const override

StreamID	getLastIncomingStreamID () const override

void	enableDoubleGoawayDrain () override

bool	onIngressUpgradeMessage (const HTTPMessage &msg) override

void	setNextEgressStreamId (StreamID nextEgressStreamID)

bool	isInitiatedStream (StreamID stream) const

bool	isStreamIngressEgressAllowed (StreamID stream) const

Public Member Functions inherited from proxygen::HTTPCodec
virtual	~HTTPCodec ()

virtual HPACKTableInfo	getHPACKTableInfo () const

virtual CodecProtocol	getProtocol () const =0

virtual const std::string &	getUserAgent () const =0

virtual size_t	onIngress (const folly::IOBuf &buf)=0

virtual bool	supportsPushTransactions () const =0

virtual bool	supportsExTransactions () const

virtual size_t	generateConnectionPreface (folly::IOBufQueue &)

virtual void	generateHeader (folly::IOBufQueue &writeBuf, StreamID stream, const HTTPMessage &msg, bool eom=false, HTTPHeaderSize *size=nullptr)=0

virtual void	generatePushPromise (folly::IOBufQueue &, StreamID, const HTTPMessage &, StreamID, bool, HTTPHeaderSize *)

virtual void	generateExHeader (folly::IOBufQueue &, StreamID, const HTTPMessage &, const HTTPCodec::ExAttributes &, bool, HTTPHeaderSize *)

virtual size_t	generateBody (folly::IOBufQueue &writeBuf, StreamID stream, std::unique_ptr< folly::IOBuf > chain, folly::Optional< uint8_t > padding, bool eom)=0

virtual size_t	generateChunkHeader (folly::IOBufQueue &writeBuf, StreamID stream, size_t length)=0

virtual size_t	generateChunkTerminator (folly::IOBufQueue &writeBuf, StreamID stream)=0

virtual size_t	generateTrailers (folly::IOBufQueue &writeBuf, StreamID stream, const HTTPHeaders &trailers)=0

virtual size_t	generateEOM (folly::IOBufQueue &writeBuf, StreamID stream)=0

virtual size_t	generateRstStream (folly::IOBufQueue &writeBuf, StreamID stream, ErrorCode code)=0

virtual size_t	generateGoaway (folly::IOBufQueue &writeBuf, StreamID lastStream, ErrorCode code, std::unique_ptr< folly::IOBuf > debugData=nullptr)=0

virtual size_t	generatePingRequest (folly::IOBufQueue &)

virtual size_t	generatePingReply (folly::IOBufQueue &, uint64_t)

virtual size_t	generateSettings (folly::IOBufQueue &)

virtual size_t	generateSettingsAck (folly::IOBufQueue &)

virtual size_t	generateWindowUpdate (folly::IOBufQueue &, StreamID, uint32_t)

virtual size_t	generatePriority (folly::IOBufQueue &, StreamID, const HTTPMessage::HTTPPriority &)

virtual size_t	generateCertificateRequest (folly::IOBufQueue &, uint16_t, std::unique_ptr< folly::IOBuf >)

virtual size_t	generateCertificate (folly::IOBufQueue &, uint16_t, std::unique_ptr< folly::IOBuf >)

virtual HTTPSettings *	getEgressSettings ()

virtual const HTTPSettings *	getIngressSettings () const

virtual void	setHeaderCodecStats (HeaderCodec::Stats *)

virtual uint32_t	getDefaultWindowSize () const

virtual size_t	addPriorityNodes (PriorityQueue &, folly::IOBufQueue &, uint8_t)

virtual StreamID	mapPriorityToDependency (uint8_t) const

virtual int8_t	mapDependencyToPriority (StreamID) const

Protected Types
enum	ClosingState { OPEN = 0, OPEN_WITH_GRACEFUL_DRAIN_ENABLED = 1, FIRST_GOAWAY_SENT = 2, CLOSING = 3, CLOSED = 4 }

Protected Member Functions
template<typename T , typename... Args>
bool	deliverCallbackIfAllowed (T callbackFn, char const *cbName, StreamID stream, Args &&...args)

Protected Attributes
TransportDirection	transportDirection_

StreamID	nextEgressStreamID_

StreamID	lastStreamID_ {0}

HTTPCodec::Callback *	callback_ {nullptr}

StreamID	ingressGoawayAck_ {std::numeric_limits<uint32_t>::max()}

StreamID	egressGoawayAck_ {std::numeric_limits<uint32_t>::max()}

std::string	goawayErrorMessage_

enum proxygen::HTTPParallelCodec::ClosingState	sessionClosing_

Additional Inherited Members
Public Types inherited from proxygen::HTTPCodec
using	StreamID = uint64_t

Static Public Attributes inherited from proxygen::HTTPCodec
static const folly::Optional< StreamID >	NoStream

static const folly::Optional< uint8_t >	NoPadding = folly::none

static const StreamID	MAX_STREAM_ID = 1u << 31

static const folly::Optional< ExAttributes >	NoExAttributes

Detailed Description

An implementation of common codec functionality used for multiple parallel stream downloads. Currently shared by SPDY and HTTP/2

Definition at line 31 of file HTTPParallelCodec.h.

Member Enumeration Documentation

enum proxygen::HTTPParallelCodec::ClosingState

protected

Enumerator
OPEN
OPEN_WITH_GRACEFUL_DRAIN_ENABLED
FIRST_GOAWAY_SENT
CLOSING
CLOSED

Definition at line 84 of file HTTPParallelCodec.h.

                     {
     OPEN = 0,
     OPEN_WITH_GRACEFUL_DRAIN_ENABLED = 1,
     FIRST_GOAWAY_SENT = 2,
     CLOSING = 3, // SPDY only
     CLOSED = 4 // HTTP2 only
   } sessionClosing_;

Constructor & Destructor Documentation

proxygen::HTTPParallelCodec::HTTPParallelCodec ( TransportDirection direction )

explicit

Definition at line 23 of file HTTPParallelCodec.cpp.

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

   : transportDirection_(direction),
     sessionClosing_(ClosingState::OPEN) {
   switch (transportDirection_) {
   case TransportDirection::DOWNSTREAM:
     nextEgressStreamID_ = 2;
     break;
   case TransportDirection::UPSTREAM:
     nextEgressStreamID_ = 1;
     break;
   default:
     LOG(FATAL) << "Unknown transport direction.";
   }
 }

Member Function Documentation

bool proxygen::HTTPParallelCodec::closeOnEgressComplete ( ) const

inlineoverridevirtual

Checks whether the socket needs to be closed when EOM is sent. This is used during CONNECT when EOF needs to be sent after upgrade to notify the server

Implements proxygen::HTTPCodec.

Definition at line 44 of file HTTPParallelCodec.h.

44 { return false; }

HTTPCodec::StreamID proxygen::HTTPParallelCodec::createStream ( )

overridevirtual

Reserve a stream ID.

Returns: A stream ID on success, or zero on error.

Implements proxygen::HTTPCodec.

Definition at line 38 of file HTTPParallelCodec.cpp.

References nextEgressStreamID_.

Referenced by proxygen::HTTP2Codec::addPriorityNodes(), TEST(), and TEST_F().

                                                   {
   auto ret = nextEgressStreamID_;
   nextEgressStreamID_ += 2;
   return ret;
 }

template<typename T , typename... Args>

bool proxygen::HTTPParallelCodec::deliverCallbackIfAllowed	(	T	callbackFn,
		char const *	cbName,
		StreamID	stream,
		Args &&...	args
	)

inlineprotected

Definition at line 93 of file HTTPParallelCodec.h.

References callback_.

Referenced by proxygen::SPDYCodec::deliverOnMessageBegin(), proxygen::HTTP2Codec::handleEndStream(), proxygen::SPDYCodec::onRstStream(), proxygen::SPDYCodec::onSynCommon(), proxygen::SPDYCodec::onWindowUpdate(), proxygen::HTTP2Codec::parseAllData(), proxygen::HTTP2Codec::parseDataFrameData(), proxygen::HTTP2Codec::parseHeadersImpl(), proxygen::SPDYCodec::parseIngress(), proxygen::HTTP2Codec::parsePriority(), proxygen::HTTP2Codec::parseRstStream(), and proxygen::HTTP2Codec::parseWindowUpdate().

                                                                  {
     if (isStreamIngressEgressAllowed(stream)) {
       if (callback_) {
         (*callback_.*callbackFn)(stream, std::forward<Args>(args)...);
       }
       return true;
     } else {
       VLOG(2) << "Suppressing " << cbName << " for stream=" <<
         stream << " egressGoawayAck_=" << egressGoawayAck_;
     }
     return false;
   }

void proxygen::HTTPParallelCodec::enableDoubleGoawayDrain ( )

overridevirtual

This enables HTTP/2 style behavior during graceful shutdown that allows 2 GOAWAYs to be sent during shutdown.

Reimplemented from proxygen::HTTPCodec.

Definition at line 58 of file HTTPParallelCodec.cpp.

References sessionClosing_.

Referenced by TEST().

                                                 {
   CHECK_EQ(sessionClosing_, ClosingState::OPEN);
   sessionClosing_ = ClosingState::OPEN_WITH_GRACEFUL_DRAIN_ENABLED;
 }

StreamID proxygen::HTTPParallelCodec::getLastIncomingStreamID ( ) const

inlineoverridevirtual

Get the identifier of the last stream started by the remote.

Reimplemented from proxygen::HTTPCodec.

Definition at line 50 of file HTTPParallelCodec.h.

50 { return lastStreamID_; }

proxygen::HTTPParallelCodec::lastStreamID_

StreamID lastStreamID_

Definition: HTTPParallelCodec.h:78

TransportDirection proxygen::HTTPParallelCodec::getTransportDirection ( ) const

inlineoverridevirtual

Get the transport direction of this codec: DOWNSTREAM if the codec receives requests from clients or UPSTREAM if the codec sends requests to servers.

Implements proxygen::HTTPCodec.

Definition at line 35 of file HTTPParallelCodec.h.

Referenced by proxygen::HTTP2Codec::generateSettings(), proxygen::HTTP2Codec::generateSettingsAck(), proxygen::HTTP2Codec::handleSettings(), and HTTPParallelCodecTest::parseImpl().

                                                             {
     return transportDirection_;
   }

bool proxygen::HTTPParallelCodec::isBusy ( ) const

inlineoverridevirtual

Check whether the codec still has at least one HTTP stream to parse.

Implements proxygen::HTTPCodec.

Definition at line 40 of file HTTPParallelCodec.h.

40 { return false; }

bool proxygen::HTTPParallelCodec::isInitiatedStream ( StreamID stream ) const

inline

Definition at line 63 of file HTTPParallelCodec.h.

References odd.

Referenced by proxygen::HTTP2Codec::checkNewStream().

                                                 {
     bool odd = stream & 0x01;
     bool upstream = (transportDirection_ == TransportDirection::UPSTREAM);
     return (odd && upstream) || (!odd && !upstream);
   }

bool proxygen::HTTPParallelCodec::isReusable ( ) const

overridevirtual

Check whether the codec can process new streams. Typically, an implementing subclass will return true when a new codec is created and false once it encounters a situation that would prevent reuse of the underlying transport (e.g., a "Connection: close" in HTTP/1.x).

Note: A return value of true means that the codec can process new connections at some reasonable point in the future; that may mean "immediately," for codecs that support pipelined or interleaved requests, or "upon completion of the current stream" for codecs that do not.

Implements proxygen::HTTPCodec.

Definition at line 49 of file HTTPParallelCodec.cpp.

References proxygen::DOWNSTREAM, ingressGoawayAck_, isWaitingToDrain(), max, nextEgressStreamID_, sessionClosing_, and transportDirection_.

Referenced by TEST(), and TEST_F().

                                          {
   return (sessionClosing_ == ClosingState::OPEN ||
           sessionClosing_ == ClosingState::OPEN_WITH_GRACEFUL_DRAIN_ENABLED ||
           (transportDirection_ == TransportDirection::DOWNSTREAM &&
            isWaitingToDrain()))
     && (ingressGoawayAck_ == std::numeric_limits<uint32_t>::max())
     && (nextEgressStreamID_ <= std::numeric_limits<int32_t>::max() - 2);
 }

bool proxygen::HTTPParallelCodec::isStreamIngressEgressAllowed ( StreamID stream ) const

inline

Definition at line 69 of file HTTPParallelCodec.h.

Referenced by proxygen::SPDYCodec::generateBody(), proxygen::HTTP2Codec::generateBody(), proxygen::SPDYCodec::generateEOM(), proxygen::HTTP2Codec::generateEOM(), proxygen::SPDYCodec::generateHeader(), proxygen::HTTP2Codec::generateHeaderImpl(), proxygen::HTTP2Codec::generatePriority(), proxygen::SPDYCodec::generatePushPromise(), proxygen::SPDYCodec::generateRstStream(), proxygen::HTTP2Codec::generateRstStream(), proxygen::SPDYCodec::generateWindowUpdate(), and proxygen::HTTP2Codec::generateWindowUpdate().

                                                            {
     bool isInitiated = isInitiatedStream(stream);
     return (isInitiated && stream <= ingressGoawayAck_) ||
       (!isInitiated && stream <= egressGoawayAck_);
   }

bool proxygen::HTTPParallelCodec::isWaitingToDrain ( ) const

overridevirtual

Returns true if this codec is in a state where it accepting new requests but will soon begin to reject new requests. For SPDY and HTTP/2, this is true when the first GOAWAY NO_ERROR is sent during graceful shutdown.

Implements proxygen::HTTPCodec.

Definition at line 44 of file HTTPParallelCodec.cpp.

References sessionClosing_.

Referenced by isReusable(), and TEST().

                                                {
   return sessionClosing_ == ClosingState::OPEN ||
     sessionClosing_ == ClosingState::FIRST_GOAWAY_SENT;
 }

void proxygen::HTTPParallelCodec::onIngressEOF ( )

inlineoverridevirtual

Finish parsing when the ingress stream has ended.

Implements proxygen::HTTPCodec.

Definition at line 47 of file HTTPParallelCodec.h.

47 {}

bool proxygen::HTTPParallelCodec::onIngressUpgradeMessage ( const HTTPMessage & )

overridevirtual

Invoked on a codec that has been upgraded to via an HTTPMessage on a different codec. The codec may return false to halt the upgrade.

Reimplemented from proxygen::HTTPCodec.

Definition at line 63 of file HTTPParallelCodec.cpp.

References proxygen::DOWNSTREAM, lastStreamID_, and transportDirection_.

Referenced by proxygen::HTTP2Codec::onIngressUpgradeMessage().

                                                                     {
   if (transportDirection_ == TransportDirection::DOWNSTREAM) {
     lastStreamID_ = 1;
   }
   return true;
 }

void proxygen::HTTPParallelCodec::setCallback ( Callback * callback )

inlineoverridevirtual

Set the callback to notify on ingress events

Parameters

callback The callback object

Implements proxygen::HTTPCodec.

Definition at line 45 of file HTTPParallelCodec.h.

References callback_.

Referenced by parseSPDY(), HTTPParallelCodecTest::SetUp(), TEST(), and TEST_F().

45 { callback_ = callback; }

proxygen::HTTPParallelCodec::callback_

HTTPCodec::Callback * callback_

Definition: HTTPParallelCodec.h:79

void proxygen::HTTPParallelCodec::setNextEgressStreamId ( StreamID nextEgressStreamID )

inline

Definition at line 55 of file HTTPParallelCodec.h.

References max.

Referenced by TEST(), and TEST_F().

                                                           {
     if (nextEgressStreamID > nextEgressStreamID_ &&
         (nextEgressStreamID & 0x1) == (nextEgressStreamID_ & 0x1) &&
         nextEgressStreamID_ < std::numeric_limits<int32_t>::max()) {
       nextEgressStreamID_ = nextEgressStreamID;
     }
   }

void proxygen::HTTPParallelCodec::setParserPaused ( bool paused )

inlineoverridevirtual

Pause or resume the ingress parser

Parameters

paused Whether the caller wants the parser to be paused

Implements proxygen::HTTPCodec.

Definition at line 46 of file HTTPParallelCodec.h.

46 {}

bool proxygen::HTTPParallelCodec::supportsParallelRequests ( ) const

inlineoverridevirtual

Check whether the codec supports the processing of multiple requests in parallel.

Implements proxygen::HTTPCodec.

Definition at line 43 of file HTTPParallelCodec.h.

43 { return true; }

bool proxygen::HTTPParallelCodec::supportsSessionFlowControl ( ) const

inlineoverridevirtual

Returns true iff this codec supports session level flow control

Reimplemented from proxygen::HTTPCodec.

Reimplemented in proxygen::SPDYCodec.

Definition at line 42 of file HTTPParallelCodec.h.

42 { return true; }

bool proxygen::HTTPParallelCodec::supportsStreamFlowControl ( ) const

inlineoverridevirtual

Returns true iff this codec supports per stream flow control

Reimplemented from proxygen::HTTPCodec.

Reimplemented in proxygen::SPDYCodec.

Definition at line 41 of file HTTPParallelCodec.h.

41 { return true; }

Member Data Documentation

HTTPCodec::Callback* proxygen::HTTPParallelCodec::callback_ {nullptr}

protected

Definition at line 79 of file HTTPParallelCodec.h.

StreamID proxygen::HTTPParallelCodec::egressGoawayAck_ {std::numeric_limits<uint32_t>::max()}

protected

Definition at line 81 of file HTTPParallelCodec.h.

Referenced by proxygen::SPDYCodec::generateGoaway(), and proxygen::HTTP2Codec::generateGoaway().

std::string proxygen::HTTPParallelCodec::goawayErrorMessage_

protected

Definition at line 82 of file HTTPParallelCodec.h.

Referenced by proxygen::HTTP2Codec::checkConnectionError(), proxygen::HTTP2Codec::checkNewStream(), proxygen::HTTP2Codec::handleSettings(), proxygen::HTTP2Codec::onIngress(), proxygen::HTTP2Codec::parseFrame(), proxygen::HTTP2Codec::parsePushPromise(), proxygen::HTTP2Codec::parseRstStream(), and proxygen::HTTP2Codec::parseWindowUpdate().

StreamID proxygen::HTTPParallelCodec::ingressGoawayAck_ {std::numeric_limits<uint32_t>::max()}

protected

Definition at line 80 of file HTTPParallelCodec.h.

StreamID proxygen::HTTPParallelCodec::lastStreamID_ {0}

protected

Definition at line 78 of file HTTPParallelCodec.h.

Referenced by proxygen::HTTP2Codec::checkNewStream(), proxygen::SPDYCodec::failSession(), onIngressUpgradeMessage(), and proxygen::SPDYCodec::onSynStream().

StreamID proxygen::HTTPParallelCodec::nextEgressStreamID_

protected

Definition at line 77 of file HTTPParallelCodec.h.

Referenced by createStream(), HTTPParallelCodec(), isReusable(), and proxygen::SPDYCodec::SPDYCodec().

enum proxygen::HTTPParallelCodec::ClosingState proxygen::HTTPParallelCodec::sessionClosing_

protected

Referenced by proxygen::HTTP2Codec::checkNewStream(), enableDoubleGoawayDrain(), proxygen::SPDYCodec::generateGoaway(), proxygen::HTTP2Codec::generateGoaway(), isReusable(), isWaitingToDrain(), and proxygen::SPDYCodec::onSynStream().

TransportDirection proxygen::HTTPParallelCodec::transportDirection_

protected

Definition at line 76 of file HTTPParallelCodec.h.

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

proxygen/lib/http/codec/HTTPParallelCodec.h
proxygen/lib/http/codec/HTTPParallelCodec.cpp

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation