//Check Queue for IOBuffer as Folly Test. void check_consistency(const folly::IOBufQueue& queue) { if(queue.options().cacheChainLength) { size_t len = queue.front() ? queue.front()->computeChainDataLength() : 0; LOG(INFO)<<"Chain Length : "<< len; EXPECT_EQ(len, queue.chainLength()); } }
bool parseRoutingData(folly::IOBufQueue& bufQueue, RoutingData& routingData) override { if (bufQueue.chainLength() == 0) { return false; } auto buf = bufQueue.move(); buf->coalesce(); // Use the first byte for hashing to a worker routingData.routingData = buf->data()[0]; routingData.bufQueue.append(std::move(buf)); return true; }
void HandlerCallbackBase::sendReply( folly::IOBufQueue queue, apache::thrift::Stream<folly::IOBufQueue>&& stream) { folly::Optional<uint32_t> crc32c = checksumIfNeeded(queue); transform(queue); auto stream_ = std::move(stream).map([](auto&& value) mutable { return value.move(); }); if (getEventBase()->isInEventBaseThread()) { req_->sendStreamReply({queue.move(), std::move(stream_)}, nullptr, crc32c); } else { getEventBase()->runInEventBaseThread([req = std::move(req_), queue = std::move(queue), stream = std::move(stream_), crc32c]() mutable { req->sendStreamReply({queue.move(), std::move(stream)}, nullptr, crc32c); }); } }
void TestAsyncTransport::addReadEvent(folly::IOBufQueue& chain, int64_t delayFromPrevious) { while (true) { unique_ptr<IOBuf> cur = chain.pop_front(); if (!cur) { break; } addReadEvent(cur->data(), cur->length(), delayFromPrevious); } }
void Cpp2Channel::read(Context* ctx, folly::IOBufQueue& q) { DestructorGuard dg(this); if (recvCallback_ && recvCallback_->shouldSample() && !sample_) { sample_.reset(new RecvCallback::sample); sample_->readBegin = Util::currentTimeUsec(); } if (!recvCallback_) { LOG(INFO) << "Received a message, but no recvCallback_ installed!"; return; } if (sample_) { sample_->readEnd = Util::currentTimeUsec(); } recvCallback_->messageReceived(q.move(), std::move(sample_)); }
/** * Mostly ripped from HTTP2Codec::generateHeader. This writes out frames * like Chrome does, breaking on 1024 - frame header, with some of the not * needed cases removed. It's specialized to write only a single continuation * frame with optionally malformed length */ void generateHeaderChrome(HPACKCodec09& headerCodec, folly::IOBufQueue& writeBuf, HTTPCodec::StreamID stream, const HTTPMessage& msg, HTTPCodec::StreamID assocStream, bool eom, HTTPHeaderSize* size, bool malformed) { VLOG(4) << "generating " << ((assocStream != 0) ? "PUSH_PROMISE" : "HEADERS") << " for stream=" << stream; std::vector<proxygen::compress::Header> allHeaders; const string& method = msg.getMethodString(); const string& scheme = (msg.isSecure() ? http2::kHttps : http2::kHttp); const string& path = msg.getURL(); const HTTPHeaders& headers = msg.getHeaders(); const string& host = headers.getSingleOrEmpty(HTTP_HEADER_HOST); allHeaders.emplace_back(http2::kMethod, method); allHeaders.emplace_back(http2::kScheme, scheme); allHeaders.emplace_back(http2::kPath, path); if (!host.empty()) { allHeaders.emplace_back(http2::kAuthority, host); } // Add the HTTP headers supplied by the caller, but skip // any per-hop headers that aren't supported in HTTP/2. msg.getHeaders().forEachWithCode( [&] (HTTPHeaderCode code, const string& name, const string& value) { // Note this code will not drop headers named by Connection. That's the // caller's job // see HTTP/2 spec, 8.1.2 DCHECK(name != "TE" || value == "trailers"); if ((name.size() > 0 && name[0] != ':') && code != HTTP_HEADER_HOST) { allHeaders.emplace_back(code, name, value); } }); headerCodec.setEncodeHeadroom(http2::kFrameHeadersBaseMaxSize); auto out = headerCodec.encode(allHeaders); if (size) { *size = headerCodec.getEncodedSize(); } IOBufQueue queue(IOBufQueue::cacheChainLength()); queue.append(std::move(out)); if (queue.chainLength() > 0) { auto chunk = queue.split(std::min((size_t)(1024 - 14), queue.chainLength())); bool endHeaders = queue.chainLength() == 0; CHECK(assocStream == 0); http2::writeHeaders(writeBuf, std::move(chunk), stream, http2::PriorityUpdate({0, false, 16}), http2::kNoPadding, eom, endHeaders); while (!endHeaders) { CHECK(queue.chainLength() == 1015); chunk = queue.split(std::min(size_t(1024 - http2::kFrameHeaderSize), queue.chainLength())); endHeaders = queue.chainLength() == 0; CHECK(endHeaders); VLOG(4) << "generating CONTINUATION for stream=" << stream; writeFrameHeaderManual(writeBuf, malformed ? 1024 : chunk->computeChainDataLength(), 9, http2::END_HEADERS, stream); writeBuf.append(std::move(chunk)); } } }