proxygen::HPACKQueue Class Reference

#include <HPACKQueue.h>

Inheritance diagram for proxygen::HPACKQueue:

Public Member Functions
	HPACKQueue (HPACKCodec &codec)
void	enqueueHeaderBlock (uint32_t seqn, std::unique_ptr< folly::IOBuf > block, size_t length, HPACK::StreamingCallback *streamingCb, bool oooOk)
uint64_t	getHolBlockCount () const
uint64_t	getQueuedBytes () const
Public Member Functions inherited from folly::DestructorCheck
virtual	~DestructorCheck ()

Private Member Functions
bool	decodeBlock (int32_t seqn, std::unique_ptr< folly::IOBuf > block, size_t length, HPACK::StreamingCallback *cb, bool ooo)
void	drainQueue ()

Private Attributes
size_t	nextSeqn_ {0}
uint64_t	holBlockCount_ {0}
uint64_t	queuedBytes_ {0}
std::deque< std::tuple< uint32_t, std::unique_ptr< folly::IOBuf >, size_t, HPACK::StreamingCallback * > >	queue_
HPACKCodec &	codec_

Detailed Description

Definition at line 21 of file HPACKQueue.h.

Constructor & Destructor Documentation

proxygen::HPACKQueue::HPACKQueue ( HPACKCodec &  codec )

inlineexplicit

Definition at line 23 of file HPACKQueue.h.

    : codec_(codec) {}

Member Function Documentation

bool proxygen::HPACKQueue::decodeBlock ( int32_t  seqn, std::unique_ptr< folly::IOBuf >  block, size_t  length, HPACK::StreamingCallback *  cb, bool  ooo  )

inlineprivate

Definition at line 85 of file HPACKQueue.h.

References c, codec_, proxygen::HPACKCodec::decodeStreaming(), and nextSeqn_.

Referenced by drainQueue(), and enqueueHeaderBlock().

                             {
    if (length > 0) {
      VLOG(5) << "decodeBlock for block=" << seqn << " len=" << length;
      folly::io::Cursor c(block.get());
      folly::DestructorCheck::Safety safety(*this);
      codec_.decodeStreaming(c, length, cb);
      if (safety.destroyed()) {
        return true;
      }
    }
    if (!ooo) {
      nextSeqn_++;
    }
    return false;
  }

void proxygen::HPACKQueue::drainQueue ( )

inlineprivate

Definition at line 103 of file HPACKQueue.h.

References decodeBlock(), folly::gen::move, cpp.ast::next(), nextSeqn_, queue_, and queuedBytes_.

Referenced by enqueueHeaderBlock().

                    {
    while (!queue_.empty() && nextSeqn_ == std::get<0>(queue_.front())) {
      auto& next = queue_.front();
      auto length = std::get<2>(next);
      if (decodeBlock(std::get<0>(next), std::move(std::get<1>(next)),
                      length, std::get<3>(next),
                      false /* in order */)) {
        return;
      }
      DCHECK_LE(length, queuedBytes_);
      queuedBytes_ -= length;
      queue_.pop_front();
    }
  }

void proxygen::HPACKQueue::enqueueHeaderBlock ( uint32_t  seqn, std::unique_ptr< folly::IOBuf >  block, size_t  length, HPACK::StreamingCallback *  streamingCb, bool  oooOk  )

inline

Definition at line 26 of file HPACKQueue.h.

References proxygen::HPACK::BAD_SEQUENCE_NUMBER, decodeBlock(), drainQueue(), holBlockCount_, int32_t, folly::gen::move, nextSeqn_, proxygen::HPACK::StreamingCallback::onDecodeError(), queue_, and queuedBytes_.

Referenced by proxygen::compress::HPACKScheme::decode().

                                      {
    if (seqn < nextSeqn_) {
      streamingCb->onDecodeError(HPACK::DecodeError::BAD_SEQUENCE_NUMBER);
      return;
    }
    if (nextSeqn_ == seqn) {
      // common case, decode immediately
      if (decodeBlock(seqn, std::move(block), length, streamingCb,
                      false /* in order */)) {
        return;
      }
      drainQueue();
    } else {
      // there's a gap, have to queue
      auto it = queue_.begin();
      while (it != queue_.end()) {
        auto qSeqn = std::get<0>(*it);
        if (seqn == qSeqn) {
          streamingCb->onDecodeError(HPACK::DecodeError::BAD_SEQUENCE_NUMBER);
          return;
        } else if (seqn < qSeqn) {
          break;
        }
        it++;
      }
      if (oooOk) {
        // out-of-order allowed.  Decode the block, but make an empty entry in
        // the queue
        if (decodeBlock(seqn, std::move(block), length, streamingCb,
                        true /* ooo */)) {
          return;
        }
        length = 0;
        streamingCb = nullptr;
      } else {
        holBlockCount_++;
      }
      VLOG(5) << "queued block=" << seqn << " len=" << length <<
        " placeholder=" << int32_t(oooOk);
      queuedBytes_ += length;
      queue_.emplace(it, seqn, std::move(block), length, streamingCb);
    }
  }

uint64_t proxygen::HPACKQueue::getHolBlockCount ( ) const

inline

Definition at line 73 of file HPACKQueue.h.

References holBlockCount_.

Referenced by proxygen::compress::HPACKScheme::getHolBlockCount().

                                    {
    return holBlockCount_;
  }

uint64_t proxygen::HPACKQueue::getQueuedBytes ( ) const

inline

Definition at line 77 of file HPACKQueue.h.

References queuedBytes_.

Referenced by proxygen::compress::HPACKScheme::decode(), and proxygen::compress::HPACKScheme::~HPACKScheme().

                                  {
    return queuedBytes_;
  }

Member Data Documentation

HPACKCodec& proxygen::HPACKQueue::codec_

private

Definition at line 123 of file HPACKQueue.h.

Referenced by decodeBlock().

uint64_t proxygen::HPACKQueue::holBlockCount_ {0}

private

Definition at line 119 of file HPACKQueue.h.

Referenced by enqueueHeaderBlock(), and getHolBlockCount().

size_t proxygen::HPACKQueue::nextSeqn_ {0}

private

Definition at line 118 of file HPACKQueue.h.

Referenced by decodeBlock(), drainQueue(), and enqueueHeaderBlock().

std::deque<std::tuple<uint32_t, std::unique_ptr<folly::IOBuf>, size_t, HPACK::StreamingCallback*> > proxygen::HPACKQueue::queue_

private

Definition at line 122 of file HPACKQueue.h.

Referenced by drainQueue(), and enqueueHeaderBlock().

uint64_t proxygen::HPACKQueue::queuedBytes_ {0}

private

Definition at line 120 of file HPACKQueue.h.

Referenced by drainQueue(), enqueueHeaderBlock(), and getQueuedBytes().

---

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

• proxygen/lib/http/codec/compress/HPACKQueue.h