From dea4eb001f78b5beeab234c2c481fd4d28af0f3b Mon Sep 17 00:00:00 2001 From: Matt Klein Date: Wed, 5 Feb 2020 09:11:56 -0800 Subject: [PATCH] http: codec refactor part 2 (#9918) This is part 1 in a set of changes to refactor the HTTP codecs so they can emit typed request headers, request trailers, response headers, and response trailers. This will help clean up various interface inconsistencies as well as unlock a greater variety of header map improvements. Signed-off-by: Matt Klein --- include/envoy/http/api_listener.h | 9 +- include/envoy/http/codec.h | 151 +- include/envoy/http/conn_pool.h | 6 +- source/common/http/codec_client.cc | 2 +- source/common/http/codec_client.h | 10 +- source/common/http/codec_wrappers.h | 24 +- source/common/http/conn_manager_impl.cc | 8 +- source/common/http/conn_manager_impl.h | 15 +- source/common/http/conn_pool_base.cc | 12 +- source/common/http/conn_pool_base.h | 12 +- source/common/http/conn_pool_base_legacy.cc | 5 +- source/common/http/conn_pool_base_legacy.h | 6 +- source/common/http/http1/codec_impl.cc | 27 +- source/common/http/http1/codec_impl.h | 44 +- source/common/http/http1/conn_pool.cc | 12 +- source/common/http/http1/conn_pool.h | 8 +- source/common/http/http1/conn_pool_legacy.cc | 14 +- source/common/http/http1/conn_pool_legacy.h | 10 +- source/common/http/http2/codec_impl.cc | 62 +- source/common/http/http2/codec_impl.h | 63 +- source/common/http/http2/conn_pool.cc | 2 +- source/common/http/http2/conn_pool.h | 2 +- source/common/http/http2/conn_pool_legacy.cc | 4 +- source/common/http/http2/conn_pool_legacy.h | 4 +- source/common/router/router.cc | 4 +- source/common/router/router.h | 14 +- source/common/upstream/health_checker_impl.cc | 2 +- source/common/upstream/health_checker_impl.h | 20 +- .../quic_listeners/quiche/codec_impl.cc | 13 +- .../quic_listeners/quiche/codec_impl.h | 2 +- .../quiche/envoy_quic_client_stream.cc | 15 +- .../quiche/envoy_quic_client_stream.h | 15 +- .../quiche/envoy_quic_server_session.cc | 6 +- .../quiche/envoy_quic_server_session.h | 4 +- .../quiche/envoy_quic_server_stream.cc | 11 +- .../quiche/envoy_quic_server_stream.h | 8 +- .../quic_listeners/quiche/envoy_quic_stream.h | 13 +- test/common/http/async_client_impl_test.cc | 62 +- test/common/http/codec_client_test.cc | 56 +- test/common/http/codec_impl_fuzz_test.cc | 101 +- test/common/http/codec_wrappers_test.cc | 43 +- test/common/http/common.h | 4 +- .../http/conn_manager_impl_fuzz_test.cc | 4 +- test/common/http/conn_manager_impl_test.cc | 212 +-- test/common/http/http1/codec_impl_test.cc | 296 ++-- .../http/http1/conn_pool_legacy_test.cc | 110 +- test/common/http/http1/conn_pool_test.cc | 110 +- test/common/http/http2/codec_impl_test.cc | 18 +- .../http/http2/conn_pool_legacy_test.cc | 105 +- test/common/http/http2/conn_pool_test.cc | 133 +- test/common/http/http2/frame_replay.cc | 2 +- test/common/http/http2/frame_replay.h | 6 +- test/common/router/router_test.cc | 1540 +++++++++-------- .../common/router/router_upstream_log_test.cc | 16 +- .../upstream/health_checker_impl_test.cc | 8 +- .../quiche/envoy_quic_client_session_test.cc | 8 +- .../quiche/envoy_quic_client_stream_test.cc | 4 +- .../quiche/envoy_quic_server_session_test.cc | 52 +- .../quiche/envoy_quic_server_stream_test.cc | 4 +- .../api_listener_integration_test.cc | 2 +- test/integration/autonomous_upstream.cc | 6 +- test/integration/autonomous_upstream.h | 4 +- test/integration/fake_upstream.cc | 4 +- test/integration/fake_upstream.h | 15 +- test/integration/http2_integration_test.cc | 10 +- .../http2_upstream_integration_test.cc | 8 +- test/integration/http_integration.cc | 20 +- test/integration/http_integration.h | 16 +- .../http_timeout_integration_test.cc | 4 +- test/integration/integration.h | 2 +- test/integration/utility.cc | 2 +- test/integration/utility.h | 2 +- test/mocks/http/api_listener.h | 4 +- test/mocks/http/conn_pool.h | 6 +- test/mocks/http/mocks.h | 6 +- test/mocks/http/stream_decoder.cc | 29 + test/mocks/http/stream_decoder.h | 37 +- test/mocks/http/stream_encoder.cc | 29 + test/mocks/http/stream_encoder.h | 26 +- 79 files changed, 2073 insertions(+), 1692 deletions(-) diff --git a/include/envoy/http/api_listener.h b/include/envoy/http/api_listener.h index 59c83a5dd93f..9c119e5c7d86 100644 --- a/include/envoy/http/api_listener.h +++ b/include/envoy/http/api_listener.h @@ -20,14 +20,15 @@ class ApiListener { * response are backed by the same Stream object. * @param is_internally_created indicates if this stream was originated by a * client, or was created by Envoy, by example as part of an internal redirect. - * @return StreamDecoder& supplies the decoder callbacks to fire into for stream decoding events. + * @return RequestDecoder& supplies the decoder callbacks to fire into for stream + * decoding events. */ - virtual StreamDecoder& newStream(StreamEncoder& response_encoder, - bool is_internally_created = false) PURE; + virtual RequestDecoder& newStream(ResponseEncoder& response_encoder, + bool is_internally_created = false) PURE; }; using ApiListenerPtr = std::unique_ptr; using ApiListenerOptRef = absl::optional>; } // namespace Http -} // namespace Envoy \ No newline at end of file +} // namespace Envoy diff --git a/include/envoy/http/codec.h b/include/envoy/http/codec.h index 55841b7e1425..fb7c8b59780b 100644 --- a/include/envoy/http/codec.h +++ b/include/envoy/http/codec.h @@ -27,89 +27,158 @@ const char MaxResponseHeadersCountOverrideKey[] = class Stream; /** - * Encodes an HTTP stream. + * Encodes an HTTP stream. This interface contains methods common to both the request and response + * path. + * TODO(mattklein123): Consider removing the StreamEncoder interface entirely and just duplicating + * the methods in both the request/response path for simplicity. */ class StreamEncoder { public: virtual ~StreamEncoder() = default; /** - * Encode 100-Continue headers. - * @param headers supplies the 100-Continue header map to encode. + * Encode a data frame. + * @param data supplies the data to encode. The data may be moved by the encoder. + * @param end_stream supplies whether this is the last data frame. */ - virtual void encode100ContinueHeaders(const HeaderMap& headers) PURE; + virtual void encodeData(Buffer::Instance& data, bool end_stream) PURE; + + /** + * @return Stream& the backing stream. + */ + virtual Stream& getStream() PURE; + /** + * Encode metadata. + * @param metadata_map_vector is the vector of metadata maps to encode. + */ + virtual void encodeMetadata(const MetadataMapVector& metadata_map_vector) PURE; +}; + +/** + * Stream encoder used for sending a request (client to server). Virtual inheritance is required + * due to a parallel implementation split between the shared base class and the derived class. + * TODO(mattklein123): In a future change the header types will be changed to differentiate from + * the response path. + */ +class RequestEncoder : public virtual StreamEncoder { +public: /** * Encode headers, optionally indicating end of stream. Response headers must * have a valid :status set. * @param headers supplies the header map to encode. - * @param end_stream supplies whether this is a header only request/response. + * @param end_stream supplies whether this is a header only request. */ virtual void encodeHeaders(const HeaderMap& headers, bool end_stream) PURE; - /** - * Encode a data frame. - * @param data supplies the data to encode. The data may be moved by the encoder. - * @param end_stream supplies whether this is the last data frame. - */ - virtual void encodeData(Buffer::Instance& data, bool end_stream) PURE; - /** * Encode trailers. This implicitly ends the stream. * @param trailers supplies the trailers to encode. */ virtual void encodeTrailers(const HeaderMap& trailers) PURE; +}; +/** + * Stream encoder used for sending a response (server to client). Virtual inheritance is required + * due to a parallel implementation split between the shared base class and the derived class. + * TODO(mattklein123): In a future change the header types will be changed to differentiate from + * the request path. + */ +class ResponseEncoder : public virtual StreamEncoder { +public: /** - * @return Stream& the backing stream. + * Encode 100-Continue headers. + * @param headers supplies the 100-Continue header map to encode. */ - virtual Stream& getStream() PURE; + virtual void encode100ContinueHeaders(const HeaderMap& headers) PURE; /** - * Encode metadata. - * @param metadata_map_vector is the vector of metadata maps to encode. + * Encode headers, optionally indicating end of stream. Response headers must + * have a valid :status set. + * @param headers supplies the header map to encode. + * @param end_stream supplies whether this is a header only response. */ - virtual void encodeMetadata(const MetadataMapVector& metadata_map_vector) PURE; + virtual void encodeHeaders(const HeaderMap& headers, bool end_stream) PURE; + + /** + * Encode trailers. This implicitly ends the stream. + * @param trailers supplies the trailers to encode. + */ + virtual void encodeTrailers(const HeaderMap& trailers) PURE; }; /** - * Decodes an HTTP stream. These are callbacks fired into a sink. + * Decodes an HTTP stream. These are callbacks fired into a sink. This interface contains methods + * common to both the request and response path. + * TODO(mattklein123): Consider removing the StreamDecoder interface entirely and just duplicating + * the methods in both the request/response path for simplicity. */ class StreamDecoder { public: virtual ~StreamDecoder() = default; /** - * Called with decoded 100-Continue headers. - * @param headers supplies the decoded 100-Continue headers map that is moved into the callee. + * Called with a decoded data frame. + * @param data supplies the decoded data. + * @param end_stream supplies whether this is the last data frame. */ - virtual void decode100ContinueHeaders(HeaderMapPtr&& headers) PURE; + virtual void decodeData(Buffer::Instance& data, bool end_stream) PURE; /** - * Called with decoded headers, optionally indicating end of stream. - * @param headers supplies the decoded headers map that is moved into the callee. - * @param end_stream supplies whether this is a header only request/response. + * Called with decoded METADATA. + * @param decoded METADATA. */ - virtual void decodeHeaders(HeaderMapPtr&& headers, bool end_stream) PURE; + virtual void decodeMetadata(MetadataMapPtr&& metadata_map) PURE; +}; +/** + * Stream decoder used for receiving a request (client to server). Virtual inheritance is required + * due to a parallel implementation split between the shared base class and the derived class. + * TODO(mattklein123): In a future change the header types will be changed to differentiate from + * the response path. + */ +class RequestDecoder : public virtual StreamDecoder { +public: /** - * Called with a decoded data frame. - * @param data supplies the decoded data. - * @param end_stream supplies whether this is the last data frame. + * Called with decoded headers, optionally indicating end of stream. + * @param headers supplies the decoded headers map. + * @param end_stream supplies whether this is a header only request. */ - virtual void decodeData(Buffer::Instance& data, bool end_stream) PURE; + virtual void decodeHeaders(HeaderMapPtr&& headers, bool end_stream) PURE; /** * Called with a decoded trailers frame. This implicitly ends the stream. * @param trailers supplies the decoded trailers. */ virtual void decodeTrailers(HeaderMapPtr&& trailers) PURE; +}; +/** + * Stream decoder used for receiving a response (server to client). Virtual inheritance is required + * due to a parallel implementation split between the shared base class and the derived class. + * TODO(mattklein123): In a future change the header types will be changed to differentiate from + * the request path. + */ +class ResponseDecoder : public virtual StreamDecoder { +public: /** - * Called with decoded METADATA. - * @param decoded METADATA. + * Called with decoded 100-Continue headers. + * @param headers supplies the decoded 100-Continue headers map. */ - virtual void decodeMetadata(MetadataMapPtr&& metadata_map) PURE; + virtual void decode100ContinueHeaders(HeaderMapPtr&& headers) PURE; + + /** + * Called with decoded headers, optionally indicating end of stream. + * @param headers supplies the decoded headers map. + * @param end_stream supplies whether this is a header only response. + */ + virtual void decodeHeaders(HeaderMapPtr&& headers, bool end_stream) PURE; + + /** + * Called with a decoded trailers frame. This implicitly ends the stream. + * @param trailers supplies the decoded trailers. + */ + virtual void decodeTrailers(HeaderMapPtr&& trailers) PURE; }; /** @@ -198,14 +267,14 @@ class Stream { */ virtual void readDisable(bool disable) PURE; - /* + /** * Return the number of bytes this stream is allowed to buffer, or 0 if there is no limit * configured. * @return uint32_t the stream's configured buffer limits. */ virtual uint32_t bufferLimit() PURE; - /* + /** * @return string_view optionally return the reason behind codec level errors. * * This information is communicated via direct accessor rather than passed with the @@ -214,7 +283,7 @@ class Stream { */ virtual absl::string_view responseDetails() { return ""; } - /* + /** * @return const Address::InstanceConstSharedPtr& the local address of the connection associated * with the stream. */ @@ -421,17 +490,17 @@ class ServerConnectionCallbacks : public virtual ConnectionCallbacks { * response are backed by the same Stream object. * @param is_internally_created indicates if this stream was originated by a * client, or was created by Envoy, by example as part of an internal redirect. - * @return StreamDecoder& supplies the decoder callbacks to fire into for stream decoding events. + * @return RequestDecoder& supplies the decoder callbacks to fire into for stream decoding + * events. */ - virtual StreamDecoder& newStream(StreamEncoder& response_encoder, - bool is_internally_created = false) PURE; + virtual RequestDecoder& newStream(ResponseEncoder& response_encoder, + bool is_internally_created = false) PURE; }; /** * A server side HTTP connection. */ class ServerConnection : public virtual Connection {}; - using ServerConnectionPtr = std::unique_ptr; /** @@ -442,9 +511,9 @@ class ClientConnection : public virtual Connection { /** * Create a new outgoing request stream. * @param response_decoder supplies the decoder callbacks to fire response events into. - * @return StreamEncoder& supplies the encoder to write the request into. + * @return RequestEncoder& supplies the encoder to write the request into. */ - virtual StreamEncoder& newStream(StreamDecoder& response_decoder) PURE; + virtual RequestEncoder& newStream(ResponseDecoder& response_decoder) PURE; }; using ClientConnectionPtr = std::unique_ptr; diff --git a/include/envoy/http/conn_pool.h b/include/envoy/http/conn_pool.h index 8ee9270e6dd5..1eb40df56561 100644 --- a/include/envoy/http/conn_pool.h +++ b/include/envoy/http/conn_pool.h @@ -60,8 +60,7 @@ class Callbacks { * connection pools the description may be different each time this is called. * @param info supplies the stream info object associated with the upstream connection. */ - virtual void onPoolReady(Http::StreamEncoder& encoder, - Upstream::HostDescriptionConstSharedPtr host, + virtual void onPoolReady(RequestEncoder& encoder, Upstream::HostDescriptionConstSharedPtr host, const StreamInfo::StreamInfo& info) PURE; }; @@ -119,7 +118,8 @@ class Instance : public Event::DeferredDeletable { * @warning Do not call cancel() from the callbacks, as the request is implicitly canceled when * the callbacks are called. */ - virtual Cancellable* newStream(Http::StreamDecoder& response_decoder, Callbacks& callbacks) PURE; + virtual Cancellable* newStream(Http::ResponseDecoder& response_decoder, + Callbacks& callbacks) PURE; /** * @return Upstream::HostDescriptionConstSharedPtr the host for which connections are pooled. diff --git a/source/common/http/codec_client.cc b/source/common/http/codec_client.cc index 04a2ca0d7b04..d4a65c5aa0ea 100644 --- a/source/common/http/codec_client.cc +++ b/source/common/http/codec_client.cc @@ -58,7 +58,7 @@ void CodecClient::deleteRequest(ActiveRequest& request) { } } -StreamEncoder& CodecClient::newStream(StreamDecoder& response_decoder) { +RequestEncoder& CodecClient::newStream(ResponseDecoder& response_decoder) { ActiveRequestPtr request(new ActiveRequest(*this, response_decoder)); request->encoder_ = &codec_->newStream(*request); request->encoder_->getStream().addCallbacks(*request); diff --git a/source/common/http/codec_client.h b/source/common/http/codec_client.h index ab29c15db85a..63d16b93ddb9 100644 --- a/source/common/http/codec_client.h +++ b/source/common/http/codec_client.h @@ -100,7 +100,7 @@ class CodecClient : Logger::Loggable, * @param response_decoder supplies the decoder to use for response callbacks. * @return StreamEncoder& the encoder to use for encoding the request. */ - StreamEncoder& newStream(StreamDecoder& response_decoder); + RequestEncoder& newStream(ResponseDecoder& response_decoder); void setConnectionStats(const Network::Connection::ConnectionStats& stats) { connection_->setConnectionStats(stats); @@ -186,9 +186,9 @@ class CodecClient : Logger::Loggable, struct ActiveRequest : LinkedObject, public Event::DeferredDeletable, public StreamCallbacks, - public StreamDecoderWrapper { - ActiveRequest(CodecClient& parent, StreamDecoder& inner) - : StreamDecoderWrapper(inner), parent_(parent) {} + public ResponseDecoderWrapper { + ActiveRequest(CodecClient& parent, ResponseDecoder& inner) + : ResponseDecoderWrapper(inner), parent_(parent) {} // StreamCallbacks void onResetStream(StreamResetReason reason, absl::string_view) override { @@ -201,7 +201,7 @@ class CodecClient : Logger::Loggable, void onPreDecodeComplete() override { parent_.responseDecodeComplete(*this); } void onDecodeComplete() override {} - StreamEncoder* encoder_{}; + RequestEncoder* encoder_{}; CodecClient& parent_; }; diff --git a/source/common/http/codec_wrappers.h b/source/common/http/codec_wrappers.h index f90bf1c0c569..ec99ddd29ceb 100644 --- a/source/common/http/codec_wrappers.h +++ b/source/common/http/codec_wrappers.h @@ -6,11 +6,11 @@ namespace Envoy { namespace Http { /** - * Wrapper for StreamDecoder that just forwards to an "inner" decoder. + * Wrapper for ResponseDecoder that just forwards to an "inner" decoder. */ -class StreamDecoderWrapper : public StreamDecoder { +class ResponseDecoderWrapper : public ResponseDecoder { public: - // StreamDecoder + // ResponseDecoder void decode100ContinueHeaders(HeaderMapPtr&& headers) override { inner_.decode100ContinueHeaders(std::move(headers)); } @@ -50,7 +50,7 @@ class StreamDecoderWrapper : public StreamDecoder { } protected: - StreamDecoderWrapper(StreamDecoder& inner) : inner_(inner) {} + ResponseDecoderWrapper(ResponseDecoder& inner) : inner_(inner) {} /** * Consumers of the wrapper generally want to know when a decode is complete. This is called @@ -59,19 +59,15 @@ class StreamDecoderWrapper : public StreamDecoder { virtual void onPreDecodeComplete() PURE; virtual void onDecodeComplete() PURE; - StreamDecoder& inner_; + ResponseDecoder& inner_; }; /** - * Wrapper for StreamEncoder that just forwards to an "inner" encoder. + * Wrapper for RequestEncoder that just forwards to an "inner" encoder. */ -class StreamEncoderWrapper : public StreamEncoder { +class RequestEncoderWrapper : public RequestEncoder { public: - // StreamEncoder - void encode100ContinueHeaders(const HeaderMap& headers) override { - inner_.encode100ContinueHeaders(headers); - } - + // RequestEncoder void encodeHeaders(const HeaderMap& headers, bool end_stream) override { inner_.encodeHeaders(headers, end_stream); if (end_stream) { @@ -98,7 +94,7 @@ class StreamEncoderWrapper : public StreamEncoder { Stream& getStream() override { return inner_.getStream(); } protected: - StreamEncoderWrapper(StreamEncoder& inner) : inner_(inner) {} + RequestEncoderWrapper(RequestEncoder& inner) : inner_(inner) {} /** * Consumers of the wrapper generally want to know when an encode is complete. This is called at @@ -106,7 +102,7 @@ class StreamEncoderWrapper : public StreamEncoder { */ virtual void onEncodeComplete() PURE; - StreamEncoder& inner_; + RequestEncoder& inner_; }; } // namespace Http diff --git a/source/common/http/conn_manager_impl.cc b/source/common/http/conn_manager_impl.cc index 3c4956339e7f..947d511fd5de 100644 --- a/source/common/http/conn_manager_impl.cc +++ b/source/common/http/conn_manager_impl.cc @@ -254,8 +254,8 @@ void ConnectionManagerImpl::doDeferredStreamDestroy(ActiveStream& stream) { } } -StreamDecoder& ConnectionManagerImpl::newStream(StreamEncoder& response_encoder, - bool is_internally_created) { +RequestDecoder& ConnectionManagerImpl::newStream(ResponseEncoder& response_encoder, + bool is_internally_created) { if (connection_idle_timer_) { connection_idle_timer_->disableTimer(); } @@ -2297,14 +2297,14 @@ bool ConnectionManagerImpl::ActiveStreamDecoderFilter::recreateStream() { // decoder because the decoder callbacks are complete. It would be good to // null out that pointer but should not be necessary. HeaderMapPtr request_headers(std::move(parent_.request_headers_)); - StreamEncoder* response_encoder = parent_.response_encoder_; + ResponseEncoder* response_encoder = parent_.response_encoder_; parent_.response_encoder_ = nullptr; response_encoder->getStream().removeCallbacks(parent_); // This functionally deletes the stream (via deferred delete) so do not // reference anything beyond this point. parent_.connection_manager_.doEndStream(this->parent_); - StreamDecoder& new_stream = parent_.connection_manager_.newStream(*response_encoder, true); + RequestDecoder& new_stream = parent_.connection_manager_.newStream(*response_encoder, true); // We don't need to copy over the old parent FilterState from the old StreamInfo if it did not // store any objects with a LifeSpan at or above DownstreamRequest. This is to avoid unnecessary // heap allocation. diff --git a/source/common/http/conn_manager_impl.h b/source/common/http/conn_manager_impl.h index 57a2d4209c02..072215fb1831 100644 --- a/source/common/http/conn_manager_impl.h +++ b/source/common/http/conn_manager_impl.h @@ -86,8 +86,8 @@ class ConnectionManagerImpl : Logger::Loggable, void onGoAway() override; // Http::ServerConnectionCallbacks - StreamDecoder& newStream(StreamEncoder& response_encoder, - bool is_internally_created = false) override; + RequestDecoder& newStream(ResponseEncoder& response_encoder, + bool is_internally_created = false) override; // Network::ConnectionCallbacks void onEvent(Network::ConnectionEvent event) override; @@ -438,7 +438,7 @@ class ConnectionManagerImpl : Logger::Loggable, struct ActiveStream : LinkedObject, public Event::DeferredDeletable, public StreamCallbacks, - public StreamDecoder, + public RequestDecoder, public FilterChainFactoryCallbacks, public Tracing::Config, public ScopeTrackedObject { @@ -504,12 +504,13 @@ class ConnectionManagerImpl : Logger::Loggable, void onBelowWriteBufferLowWatermark() override; // Http::StreamDecoder - void decode100ContinueHeaders(HeaderMapPtr&&) override { NOT_REACHED_GCOVR_EXCL_LINE; } - void decodeHeaders(HeaderMapPtr&& headers, bool end_stream) override; void decodeData(Buffer::Instance& data, bool end_stream) override; - void decodeTrailers(HeaderMapPtr&& trailers) override; void decodeMetadata(MetadataMapPtr&&) override; + // Http::RequestDecoder + void decodeHeaders(HeaderMapPtr&& headers, bool end_stream) override; + void decodeTrailers(HeaderMapPtr&& trailers) override; + // Http::FilterChainFactoryCallbacks void addStreamDecoderFilter(StreamDecoderFilterSharedPtr filter) override { addStreamDecoderFilterWorker(filter, false); @@ -654,7 +655,7 @@ class ConnectionManagerImpl : Logger::Loggable, Router::ScopedConfigConstSharedPtr snapped_scoped_routes_config_; Tracing::SpanPtr active_span_; const uint64_t stream_id_; - StreamEncoder* response_encoder_{}; + ResponseEncoder* response_encoder_{}; HeaderMapPtr continue_headers_; HeaderMapPtr response_headers_; Buffer::WatermarkBufferPtr buffered_response_data_; diff --git a/source/common/http/conn_pool_base.cc b/source/common/http/conn_pool_base.cc index 89e63a7d1e70..da9736a4e607 100644 --- a/source/common/http/conn_pool_base.cc +++ b/source/common/http/conn_pool_base.cc @@ -54,7 +54,8 @@ void ConnPoolImplBase::tryCreateNewConnection() { } } -void ConnPoolImplBase::attachRequestToClient(ActiveClient& client, StreamDecoder& response_decoder, +void ConnPoolImplBase::attachRequestToClient(ActiveClient& client, + ResponseDecoder& response_decoder, ConnectionPool::Callbacks& callbacks) { ASSERT(client.state_ == ActiveClient::State::READY); @@ -65,7 +66,7 @@ void ConnPoolImplBase::attachRequestToClient(ActiveClient& client, StreamDecoder host_->cluster().stats().upstream_rq_pending_overflow_.inc(); } else { ENVOY_CONN_LOG(debug, "creating stream", *client.codec_client_); - StreamEncoder& new_encoder = client.newStreamEncoder(response_decoder); + RequestEncoder& new_encoder = client.newStreamEncoder(response_decoder); client.remaining_requests_--; if (client.remaining_requests_ == 0) { @@ -110,7 +111,7 @@ void ConnPoolImplBase::onRequestClosed(ActiveClient& client, bool delay_attachin } } -ConnectionPool::Cancellable* ConnPoolImplBase::newStream(Http::StreamDecoder& response_decoder, +ConnectionPool::Cancellable* ConnPoolImplBase::newStream(ResponseDecoder& response_decoder, ConnectionPool::Callbacks& callbacks) { if (!ready_clients_.empty()) { ActiveClient& client = *ready_clients_.front(); @@ -317,7 +318,7 @@ void ConnPoolImplBase::onConnectionEvent(ConnPoolImplBase::ActiveClient& client, } } -ConnPoolImplBase::PendingRequest::PendingRequest(ConnPoolImplBase& parent, StreamDecoder& decoder, +ConnPoolImplBase::PendingRequest::PendingRequest(ConnPoolImplBase& parent, ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) : parent_(parent), decoder_(decoder), callbacks_(callbacks) { parent_.host_->cluster().stats().upstream_rq_pending_total_.inc(); @@ -331,7 +332,8 @@ ConnPoolImplBase::PendingRequest::~PendingRequest() { } ConnectionPool::Cancellable* -ConnPoolImplBase::newPendingRequest(StreamDecoder& decoder, ConnectionPool::Callbacks& callbacks) { +ConnPoolImplBase::newPendingRequest(ResponseDecoder& decoder, + ConnectionPool::Callbacks& callbacks) { ENVOY_LOG(debug, "queueing request due to no available connections"); PendingRequestPtr pending_request(new PendingRequest(*this, decoder, callbacks)); pending_request->moveIntoList(std::move(pending_request), pending_requests_); diff --git a/source/common/http/conn_pool_base.h b/source/common/http/conn_pool_base.h index 3d2fea253e19..a0e0671e650f 100644 --- a/source/common/http/conn_pool_base.h +++ b/source/common/http/conn_pool_base.h @@ -18,7 +18,7 @@ class ConnPoolImplBase : public ConnectionPool::Instance, protected Logger::Loggable { public: // ConnectionPool::Instance - ConnectionPool::Cancellable* newStream(StreamDecoder& response_decoder, + ConnectionPool::Cancellable* newStream(ResponseDecoder& response_decoder, ConnectionPool::Callbacks& callbacks) override; void addDrainedCallback(DrainedCb cb) override; bool hasActiveConnections() const override; @@ -68,7 +68,7 @@ class ConnPoolImplBase : public ConnectionPool::Instance, virtual bool hasActiveRequests() const PURE; virtual bool closingWithIncompleteRequest() const PURE; - virtual StreamEncoder& newStreamEncoder(StreamDecoder& response_decoder) PURE; + virtual RequestEncoder& newStreamEncoder(ResponseDecoder& response_decoder) PURE; enum class State { CONNECTING, // Connection is not yet established. @@ -94,7 +94,7 @@ class ConnPoolImplBase : public ConnectionPool::Instance, using ActiveClientPtr = std::unique_ptr; struct PendingRequest : LinkedObject, public ConnectionPool::Cancellable { - PendingRequest(ConnPoolImplBase& parent, StreamDecoder& decoder, + PendingRequest(ConnPoolImplBase& parent, ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks); ~PendingRequest() override; @@ -102,7 +102,7 @@ class ConnPoolImplBase : public ConnectionPool::Instance, void cancel() override { parent_.onPendingRequestCancel(*this); } ConnPoolImplBase& parent_; - StreamDecoder& decoder_; + ResponseDecoder& decoder_; ConnectionPool::Callbacks& callbacks_; }; @@ -118,7 +118,7 @@ class ConnPoolImplBase : public ConnectionPool::Instance, std::list& owningList(ActiveClient::State state); // Creates a new PendingRequest and enqueues it into the request queue. - ConnectionPool::Cancellable* newPendingRequest(StreamDecoder& decoder, + ConnectionPool::Cancellable* newPendingRequest(ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks); // Removes the PendingRequest from the list of requests. Called when the PendingRequest is // cancelled, e.g. when the stream is reset before a connection has been established. @@ -140,7 +140,7 @@ class ConnPoolImplBase : public ConnectionPool::Instance, void onConnectionEvent(ActiveClient& client, Network::ConnectionEvent event); void checkForDrained(); void onUpstreamReady(); - void attachRequestToClient(ActiveClient& client, StreamDecoder& response_decoder, + void attachRequestToClient(ActiveClient& client, ResponseDecoder& response_decoder, ConnectionPool::Callbacks& callbacks); // Creates a new connection if allowed by resourceManager, or if created to avoid diff --git a/source/common/http/conn_pool_base_legacy.cc b/source/common/http/conn_pool_base_legacy.cc index f41e6ea67b12..9476a846a321 100644 --- a/source/common/http/conn_pool_base_legacy.cc +++ b/source/common/http/conn_pool_base_legacy.cc @@ -38,7 +38,7 @@ ConnPoolImplBase::ActiveClient::ConnectionState ConnPoolImplBase::ActiveClient:: return Connected; } -ConnPoolImplBase::PendingRequest::PendingRequest(ConnPoolImplBase& parent, StreamDecoder& decoder, +ConnPoolImplBase::PendingRequest::PendingRequest(ConnPoolImplBase& parent, ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) : parent_(parent), decoder_(decoder), callbacks_(callbacks) { parent_.host_->cluster().stats().upstream_rq_pending_total_.inc(); @@ -52,7 +52,8 @@ ConnPoolImplBase::PendingRequest::~PendingRequest() { } ConnectionPool::Cancellable* -ConnPoolImplBase::newPendingRequest(StreamDecoder& decoder, ConnectionPool::Callbacks& callbacks) { +ConnPoolImplBase::newPendingRequest(ResponseDecoder& decoder, + ConnectionPool::Callbacks& callbacks) { ENVOY_LOG(debug, "queueing request due to no available connections"); PendingRequestPtr pending_request(new PendingRequest(*this, decoder, callbacks)); pending_request->moveIntoList(std::move(pending_request), pending_requests_); diff --git a/source/common/http/conn_pool_base_legacy.h b/source/common/http/conn_pool_base_legacy.h index 5a2cba34708d..edcd2529156d 100644 --- a/source/common/http/conn_pool_base_legacy.h +++ b/source/common/http/conn_pool_base_legacy.h @@ -40,7 +40,7 @@ class ConnPoolImplBase : protected Logger::Loggable { }; struct PendingRequest : LinkedObject, public ConnectionPool::Cancellable { - PendingRequest(ConnPoolImplBase& parent, StreamDecoder& decoder, + PendingRequest(ConnPoolImplBase& parent, ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks); ~PendingRequest() override; @@ -48,14 +48,14 @@ class ConnPoolImplBase : protected Logger::Loggable { void cancel() override { parent_.onPendingRequestCancel(*this); } ConnPoolImplBase& parent_; - StreamDecoder& decoder_; + ResponseDecoder& decoder_; ConnectionPool::Callbacks& callbacks_; }; using PendingRequestPtr = std::unique_ptr; // Creates a new PendingRequest and enqueues it into the request queue. - ConnectionPool::Cancellable* newPendingRequest(StreamDecoder& decoder, + ConnectionPool::Cancellable* newPendingRequest(ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks); // Removes the PendingRequest from the list of requests. Called when the PendingRequest is // cancelled, e.g. when the stream is reset before a connection has been established. diff --git a/source/common/http/http1/codec_impl.cc b/source/common/http/http1/codec_impl.cc index 2e11ec6f33f7..8cb2190267eb 100644 --- a/source/common/http/http1/codec_impl.cc +++ b/source/common/http/http1/codec_impl.cc @@ -63,9 +63,9 @@ const std::string StreamEncoderImpl::LAST_CHUNK = "0\r\n"; StreamEncoderImpl::StreamEncoderImpl(ConnectionImpl& connection, HeaderKeyFormatter* header_key_formatter) - : connection_(connection), header_key_formatter_(header_key_formatter), chunk_encoding_(true), - processing_100_continue_(false), is_response_to_head_request_(false), - is_content_length_allowed_(true) { + : connection_(connection), chunk_encoding_(true), processing_100_continue_(false), + is_response_to_head_request_(false), is_content_length_allowed_(true), + header_key_formatter_(header_key_formatter) { if (connection_.connection().aboveHighWatermark()) { runHighWatermarkCallbacks(); } @@ -94,14 +94,14 @@ void StreamEncoderImpl::encodeFormattedHeader(absl::string_view key, absl::strin } } -void StreamEncoderImpl::encode100ContinueHeaders(const HeaderMap& headers) { +void ResponseEncoderImpl::encode100ContinueHeaders(const HeaderMap& headers) { ASSERT(headers.Status()->value() == "100"); processing_100_continue_ = true; encodeHeaders(headers, false); processing_100_continue_ = false; } -void StreamEncoderImpl::encodeHeaders(const HeaderMap& headers, bool end_stream) { +void StreamEncoderImpl::encodeHeadersBase(const HeaderMap& headers, bool end_stream) { bool saw_content_length = false; headers.iterate( [](const HeaderEntry& header, void* context) -> HeaderMap::Iterate { @@ -204,7 +204,7 @@ void StreamEncoderImpl::encodeData(Buffer::Instance& data, bool end_stream) { } } -void StreamEncoderImpl::encodeTrailers(const HeaderMap& trailers) { +void StreamEncoderImpl::encodeTrailersBase(const HeaderMap& trailers) { if (!connection_.enableTrailers()) { return endEncode(); } @@ -274,8 +274,11 @@ const Network::Address::InstanceConstSharedPtr& StreamEncoderImpl::connectionLoc static const char RESPONSE_PREFIX[] = "HTTP/1.1 "; static const char HTTP_10_RESPONSE_PREFIX[] = "HTTP/1.0 "; -void ResponseStreamEncoderImpl::encodeHeaders(const HeaderMap& headers, bool end_stream) { +void ResponseEncoderImpl::encodeHeaders(const HeaderMap& headers, bool end_stream) { started_response_ = true; + + // The contract is that client codecs must ensure that :status is present. + ASSERT(headers.Status() != nullptr); uint64_t numeric_status = Utility::getResponseStatus(headers); if (connection_.protocol() == Protocol::Http10 && connection_.supports_http_10()) { @@ -302,12 +305,12 @@ void ResponseStreamEncoderImpl::encodeHeaders(const HeaderMap& headers, bool end setIsContentLengthAllowed(true); } - StreamEncoderImpl::encodeHeaders(headers, end_stream); + encodeHeadersBase(headers, end_stream); } static const char REQUEST_POSTFIX[] = " HTTP/1.1\r\n"; -void RequestStreamEncoderImpl::encodeHeaders(const HeaderMap& headers, bool end_stream) { +void RequestEncoderImpl::encodeHeaders(const HeaderMap& headers, bool end_stream) { const HeaderEntry* method = headers.Method(); const HeaderEntry* path = headers.Path(); if (!method || !path) { @@ -322,7 +325,7 @@ void RequestStreamEncoderImpl::encodeHeaders(const HeaderMap& headers, bool end_ connection_.copyToBuffer(path->value().getStringView().data(), path->value().size()); connection_.copyToBuffer(REQUEST_POSTFIX, sizeof(REQUEST_POSTFIX) - 1); - StreamEncoderImpl::encodeHeaders(headers, end_stream); + encodeHeadersBase(headers, end_stream); } http_parser_settings ConnectionImpl::settings_{ @@ -843,7 +846,7 @@ bool ClientConnectionImpl::cannotHaveBody() { } } -StreamEncoder& ClientConnectionImpl::newStream(StreamDecoder& response_decoder) { +RequestEncoder& ClientConnectionImpl::newStream(ResponseDecoder& response_decoder) { if (resetStreamCalled()) { throw CodecClientException("cannot create new streams after calling reset"); } @@ -852,7 +855,7 @@ StreamEncoder& ClientConnectionImpl::newStream(StreamDecoder& response_decoder) // reusing this connection. This is done when the final pipeline response is received. ASSERT(connection_.readEnabled()); - request_encoder_ = std::make_unique(*this, header_key_formatter_.get()); + request_encoder_ = std::make_unique(*this, header_key_formatter_.get()); pending_responses_.emplace_back(&response_decoder); return *request_encoder_; } diff --git a/source/common/http/http1/codec_impl.h b/source/common/http/http1/codec_impl.h index 497e64c65b30..4dc1744b9e9d 100644 --- a/source/common/http/http1/codec_impl.h +++ b/source/common/http/http1/codec_impl.h @@ -41,16 +41,13 @@ class ConnectionImpl; /** * Base class for HTTP/1.1 request and response encoders. */ -class StreamEncoderImpl : public StreamEncoder, +class StreamEncoderImpl : public virtual StreamEncoder, public Stream, Logger::Loggable, public StreamCallbackHelper { public: // Http::StreamEncoder - void encode100ContinueHeaders(const HeaderMap& headers) override; - void encodeHeaders(const HeaderMap& headers, bool end_stream) override; void encodeData(Buffer::Instance& data, bool end_stream) override; - void encodeTrailers(const HeaderMap& trailers) override; void encodeMetadata(const MetadataMapVector&) override; Stream& getStream() override { return *this; } @@ -68,12 +65,18 @@ class StreamEncoderImpl : public StreamEncoder, protected: StreamEncoderImpl(ConnectionImpl& connection, HeaderKeyFormatter* header_key_formatter); + void setIsContentLengthAllowed(bool value) { is_content_length_allowed_ = value; } + void encodeHeadersBase(const HeaderMap& headers, bool end_stream); + void encodeTrailersBase(const HeaderMap& headers); static const std::string CRLF; static const std::string LAST_CHUNK; ConnectionImpl& connection_; - void setIsContentLengthAllowed(bool value) { is_content_length_allowed_ = value; } + bool chunk_encoding_ : 1; + bool processing_100_continue_ : 1; + bool is_response_to_head_request_ : 1; + bool is_content_length_allowed_ : 1; private: /** @@ -100,25 +103,23 @@ class StreamEncoderImpl : public StreamEncoder, void encodeFormattedHeader(absl::string_view key, absl::string_view value); const HeaderKeyFormatter* const header_key_formatter_; - bool chunk_encoding_ : 1; - bool processing_100_continue_ : 1; - bool is_response_to_head_request_ : 1; - bool is_content_length_allowed_ : 1; absl::string_view details_; }; /** * HTTP/1.1 response encoder. */ -class ResponseStreamEncoderImpl : public StreamEncoderImpl { +class ResponseEncoderImpl : public StreamEncoderImpl, public ResponseEncoder { public: - ResponseStreamEncoderImpl(ConnectionImpl& connection, HeaderKeyFormatter* header_key_formatter) + ResponseEncoderImpl(ConnectionImpl& connection, HeaderKeyFormatter* header_key_formatter) : StreamEncoderImpl(connection, header_key_formatter) {} bool startedResponse() { return started_response_; } - // Http::StreamEncoder + // Http::ResponseEncoder + void encode100ContinueHeaders(const HeaderMap& headers) override; void encodeHeaders(const HeaderMap& headers, bool end_stream) override; + void encodeTrailers(const HeaderMap& trailers) override { encodeTrailersBase(trailers); } private: bool started_response_{}; @@ -127,14 +128,15 @@ class ResponseStreamEncoderImpl : public StreamEncoderImpl { /** * HTTP/1.1 request encoder. */ -class RequestStreamEncoderImpl : public StreamEncoderImpl { +class RequestEncoderImpl : public StreamEncoderImpl, public RequestEncoder { public: - RequestStreamEncoderImpl(ConnectionImpl& connection, HeaderKeyFormatter* header_key_formatter) + RequestEncoderImpl(ConnectionImpl& connection, HeaderKeyFormatter* header_key_formatter) : StreamEncoderImpl(connection, header_key_formatter) {} bool headRequest() { return head_request_; } - // Http::StreamEncoder + // Http::RequestEncoder void encodeHeaders(const HeaderMap& headers, bool end_stream) override; + void encodeTrailers(const HeaderMap& trailers) override { encodeTrailersBase(trailers); } private: bool head_request_{}; @@ -341,8 +343,8 @@ class ServerConnectionImpl : public ServerConnection, public ConnectionImpl { : response_encoder_(connection, header_key_formatter) {} HeaderString request_url_; - StreamDecoder* request_decoder_{}; - ResponseStreamEncoderImpl response_encoder_; + RequestDecoder* request_decoder_{}; + ResponseEncoderImpl response_encoder_; bool remote_complete_{}; }; @@ -384,13 +386,13 @@ class ClientConnectionImpl : public ClientConnection, public ConnectionImpl { const uint32_t max_response_headers_count); // Http::ClientConnection - StreamEncoder& newStream(StreamDecoder& response_decoder) override; + RequestEncoder& newStream(ResponseDecoder& response_decoder) override; private: struct PendingResponse { - PendingResponse(StreamDecoder* decoder) : decoder_(decoder) {} + PendingResponse(ResponseDecoder* decoder) : decoder_(decoder) {} - StreamDecoder* decoder_; + ResponseDecoder* decoder_; bool head_request_{}; }; @@ -409,7 +411,7 @@ class ClientConnectionImpl : public ClientConnection, public ConnectionImpl { void onAboveHighWatermark() override; void onBelowLowWatermark() override; - std::unique_ptr request_encoder_; + std::unique_ptr request_encoder_; std::list pending_responses_; // Set true between receiving 100-Continue headers and receiving the spurious onMessageComplete. bool ignore_message_complete_for_100_continue_{}; diff --git a/source/common/http/http1/conn_pool.cc b/source/common/http/http1/conn_pool.cc index ec2dd558706c..89499113d747 100644 --- a/source/common/http/http1/conn_pool.cc +++ b/source/common/http/http1/conn_pool.cc @@ -65,11 +65,11 @@ void ConnPoolImpl::onResponseComplete(ActiveClient& client) { } } -ConnPoolImpl::StreamWrapper::StreamWrapper(StreamDecoder& response_decoder, ActiveClient& parent) - : StreamEncoderWrapper(parent.codec_client_->newStream(*this)), - StreamDecoderWrapper(response_decoder), parent_(parent) { +ConnPoolImpl::StreamWrapper::StreamWrapper(ResponseDecoder& response_decoder, ActiveClient& parent) + : RequestEncoderWrapper(parent.codec_client_->newStream(*this)), + ResponseDecoderWrapper(response_decoder), parent_(parent) { - StreamEncoderWrapper::inner_.getStream().addCallbacks(*this); + RequestEncoderWrapper::inner_.getStream().addCallbacks(*this); } ConnPoolImpl::StreamWrapper::~StreamWrapper() { @@ -99,7 +99,7 @@ void ConnPoolImpl::StreamWrapper::decodeHeaders(HeaderMapPtr&& headers, bool end close_connection_ = true; } - StreamDecoderWrapper::decodeHeaders(std::move(headers), end_stream); + ResponseDecoderWrapper::decodeHeaders(std::move(headers), end_stream); } void ConnPoolImpl::StreamWrapper::onDecodeComplete() { @@ -121,7 +121,7 @@ bool ConnPoolImpl::ActiveClient::closingWithIncompleteRequest() const { return (stream_wrapper_ != nullptr) && (!stream_wrapper_->decode_complete_); } -StreamEncoder& ConnPoolImpl::ActiveClient::newStreamEncoder(StreamDecoder& response_decoder) { +RequestEncoder& ConnPoolImpl::ActiveClient::newStreamEncoder(ResponseDecoder& response_decoder) { ASSERT(!stream_wrapper_); stream_wrapper_ = std::make_unique(response_decoder, *this); return *stream_wrapper_; diff --git a/source/common/http/http1/conn_pool.h b/source/common/http/http1/conn_pool.h index c9b013b12676..4a7d7c8b704a 100644 --- a/source/common/http/http1/conn_pool.h +++ b/source/common/http/http1/conn_pool.h @@ -35,10 +35,10 @@ class ConnPoolImpl : public ConnPoolImplBase { protected: struct ActiveClient; - struct StreamWrapper : public StreamEncoderWrapper, - public StreamDecoderWrapper, + struct StreamWrapper : public RequestEncoderWrapper, + public ResponseDecoderWrapper, public StreamCallbacks { - StreamWrapper(StreamDecoder& response_decoder, ActiveClient& parent); + StreamWrapper(ResponseDecoder& response_decoder, ActiveClient& parent); ~StreamWrapper() override; // StreamEncoderWrapper @@ -72,7 +72,7 @@ class ConnPoolImpl : public ConnPoolImplBase { // ConnPoolImplBase::ActiveClient bool hasActiveRequests() const override; bool closingWithIncompleteRequest() const override; - StreamEncoder& newStreamEncoder(StreamDecoder& response_decoder) override; + RequestEncoder& newStreamEncoder(ResponseDecoder& response_decoder) override; StreamWrapperPtr stream_wrapper_; }; diff --git a/source/common/http/http1/conn_pool_legacy.cc b/source/common/http/http1/conn_pool_legacy.cc index 6f8533529843..9f761c768a9a 100644 --- a/source/common/http/http1/conn_pool_legacy.cc +++ b/source/common/http/http1/conn_pool_legacy.cc @@ -68,7 +68,7 @@ bool ConnPoolImpl::hasActiveConnections() const { return !pending_requests_.empty() || !busy_clients_.empty(); } -void ConnPoolImpl::attachRequestToClient(ActiveClient& client, StreamDecoder& response_decoder, +void ConnPoolImpl::attachRequestToClient(ActiveClient& client, ResponseDecoder& response_decoder, ConnectionPool::Callbacks& callbacks) { ASSERT(!client.stream_wrapper_); host_->cluster().stats().upstream_rq_total_.inc(); @@ -96,7 +96,7 @@ void ConnPoolImpl::createNewConnection() { client->moveIntoList(std::move(client), busy_clients_); } -ConnectionPool::Cancellable* ConnPoolImpl::newStream(StreamDecoder& response_decoder, +ConnectionPool::Cancellable* ConnPoolImpl::newStream(ResponseDecoder& response_decoder, ConnectionPool::Callbacks& callbacks) { if (!ready_clients_.empty()) { ready_clients_.front()->moveBetweenLists(ready_clients_, busy_clients_); @@ -254,11 +254,11 @@ void ConnPoolImpl::processIdleClient(ActiveClient& client, bool delay) { checkForDrained(); } -ConnPoolImpl::StreamWrapper::StreamWrapper(StreamDecoder& response_decoder, ActiveClient& parent) - : StreamEncoderWrapper(parent.codec_client_->newStream(*this)), - StreamDecoderWrapper(response_decoder), parent_(parent) { +ConnPoolImpl::StreamWrapper::StreamWrapper(ResponseDecoder& response_decoder, ActiveClient& parent) + : RequestEncoderWrapper(parent.codec_client_->newStream(*this)), + ResponseDecoderWrapper(response_decoder), parent_(parent) { - StreamEncoderWrapper::inner_.getStream().addCallbacks(*this); + RequestEncoderWrapper::inner_.getStream().addCallbacks(*this); parent_.parent_.host_->cluster().stats().upstream_rq_active_.inc(); parent_.parent_.host_->stats().rq_active_.inc(); @@ -297,7 +297,7 @@ void ConnPoolImpl::StreamWrapper::decodeHeaders(HeaderMapPtr&& headers, bool end close_connection_ = true; } - StreamDecoderWrapper::decodeHeaders(std::move(headers), end_stream); + ResponseDecoderWrapper::decodeHeaders(std::move(headers), end_stream); } void ConnPoolImpl::StreamWrapper::onDecodeComplete() { diff --git a/source/common/http/http1/conn_pool_legacy.h b/source/common/http/http1/conn_pool_legacy.h index e2f9aa030988..75065bace407 100644 --- a/source/common/http/http1/conn_pool_legacy.h +++ b/source/common/http/http1/conn_pool_legacy.h @@ -44,7 +44,7 @@ class ConnPoolImpl : public ConnectionPool::Instance, public Legacy::ConnPoolImp void addDrainedCallback(DrainedCb cb) override; void drainConnections() override; bool hasActiveConnections() const override; - ConnectionPool::Cancellable* newStream(StreamDecoder& response_decoder, + ConnectionPool::Cancellable* newStream(ResponseDecoder& response_decoder, ConnectionPool::Callbacks& callbacks) override; Upstream::HostDescriptionConstSharedPtr host() const override { return host_; }; @@ -54,10 +54,10 @@ class ConnPoolImpl : public ConnectionPool::Instance, public Legacy::ConnPoolImp protected: struct ActiveClient; - struct StreamWrapper : public StreamEncoderWrapper, - public StreamDecoderWrapper, + struct StreamWrapper : public RequestEncoderWrapper, + public ResponseDecoderWrapper, public StreamCallbacks { - StreamWrapper(StreamDecoder& response_decoder, ActiveClient& parent); + StreamWrapper(ResponseDecoder& response_decoder, ActiveClient& parent); ~StreamWrapper() override; // StreamEncoderWrapper @@ -108,7 +108,7 @@ class ConnPoolImpl : public ConnectionPool::Instance, public Legacy::ConnPoolImp using ActiveClientPtr = std::unique_ptr; - void attachRequestToClient(ActiveClient& client, StreamDecoder& response_decoder, + void attachRequestToClient(ActiveClient& client, ResponseDecoder& response_decoder, ConnectionPool::Callbacks& callbacks); virtual CodecClientPtr createCodecClient(Upstream::Host::CreateConnectionData& data) PURE; void createNewConnection(); diff --git a/source/common/http/http2/codec_impl.cc b/source/common/http/http2/codec_impl.cc index e2fb633376ce..1542bda34b8d 100644 --- a/source/common/http/http2/codec_impl.cc +++ b/source/common/http/http2/codec_impl.cc @@ -88,12 +88,12 @@ void ConnectionImpl::StreamImpl::buildHeaders(std::vector& final_hea &final_headers); } -void ConnectionImpl::StreamImpl::encode100ContinueHeaders(const HeaderMap& headers) { +void ConnectionImpl::ServerStreamImpl::encode100ContinueHeaders(const HeaderMap& headers) { ASSERT(headers.Status()->value() == "100"); encodeHeaders(headers, false); } -void ConnectionImpl::StreamImpl::encodeHeaders(const HeaderMap& headers, bool end_stream) { +void ConnectionImpl::StreamImpl::encodeHeadersBase(const HeaderMap& headers, bool end_stream) { std::vector final_headers; // This must exist outside of the scope of isUpgrade as the underlying memory is @@ -122,7 +122,7 @@ void ConnectionImpl::StreamImpl::encodeHeaders(const HeaderMap& headers, bool en parent_.sendPendingFrames(); } -void ConnectionImpl::StreamImpl::encodeTrailers(const HeaderMap& trailers) { +void ConnectionImpl::StreamImpl::encodeTrailersBase(const HeaderMap& trailers) { ASSERT(!local_end_stream_); local_end_stream_ = true; if (pending_send_data_.length() > 0) { @@ -185,9 +185,32 @@ void ConnectionImpl::StreamImpl::pendingRecvBufferLowWatermark() { readDisable(false); } -void ConnectionImpl::StreamImpl::decodeHeaders() { - maybeTransformUpgradeFromH2ToH1(); - decoder_->decodeHeaders(std::move(headers_), remote_end_stream_); +void ConnectionImpl::ClientStreamImpl::decodeHeaders() { + if (!upgrade_type_.empty() && headers_->Status()) { + Http::Utility::transformUpgradeResponseFromH2toH1(*headers_, upgrade_type_); + } + + if (headers_->Status()->value() == "100") { + ASSERT(!remote_end_stream_); + response_decoder_.decode100ContinueHeaders(std::move(headers_)); + } else { + response_decoder_.decodeHeaders(std::move(headers_), remote_end_stream_); + } +} + +void ConnectionImpl::ClientStreamImpl::decodeTrailers() { + response_decoder_.decodeTrailers(std::move(headers_)); +} + +void ConnectionImpl::ServerStreamImpl::decodeHeaders() { + if (Http::Utility::isH2UpgradeRequest(*headers_)) { + Http::Utility::transformUpgradeRequestFromH2toH1(*headers_); + } + request_decoder_->decodeHeaders(std::move(headers_), remote_end_stream_); +} + +void ConnectionImpl::ServerStreamImpl::decodeTrailers() { + request_decoder_->decodeTrailers(std::move(headers_)); } void ConnectionImpl::StreamImpl::pendingSendBufferHighWatermark() { @@ -344,7 +367,7 @@ MetadataDecoder& ConnectionImpl::StreamImpl::getMetadataDecoder() { } void ConnectionImpl::StreamImpl::onMetadataDecoded(MetadataMapPtr&& metadata_map_ptr) { - decoder_->decodeMetadata(std::move(metadata_map_ptr)); + decoder().decodeMetadata(std::move(metadata_map_ptr)); } ConnectionImpl::ConnectionImpl(Network::Connection& connection, Stats::Scope& stats, @@ -492,14 +515,7 @@ int ConnectionImpl::onFrameReceived(const nghttp2_frame* frame) { if (CodeUtility::is1xx(Http::Utility::getResponseStatus(*stream->headers_))) { stream->waiting_for_non_informational_headers_ = true; } - - if (stream->headers_->Status()->value() == "100") { - ASSERT(!stream->remote_end_stream_); - stream->decoder_->decode100ContinueHeaders(std::move(stream->headers_)); - } else { - stream->decodeHeaders(); - } - break; + FALLTHRU; } case NGHTTP2_HCAT_REQUEST: { @@ -522,7 +538,7 @@ int ConnectionImpl::onFrameReceived(const nghttp2_frame* frame) { stats_.too_many_header_frames_.inc(); throw CodecProtocolException("Unexpected 'trailers' with no end stream."); } else { - stream->decoder_->decodeTrailers(std::move(stream->headers_)); + stream->decodeTrailers(); } } else { ASSERT(!nghttp2_session_check_server_session(session_)); @@ -552,7 +568,7 @@ int ConnectionImpl::onFrameReceived(const nghttp2_frame* frame) { // It's possible that we are waiting to send a deferred reset, so only raise data if local // is not complete. if (!stream->deferred_reset_) { - stream->decoder_->decodeData(stream->pending_recv_data_, stream->remote_end_stream_); + stream->decoder().decodeData(stream->pending_recv_data_, stream->remote_end_stream_); } stream->pending_recv_data_.drain(stream->pending_recv_data_.length()); @@ -1062,17 +1078,17 @@ ClientConnectionImpl::ClientConnectionImpl(Network::Connection& connection, allow_metadata_ = http2_settings.allow_metadata_; } -Http::StreamEncoder& ClientConnectionImpl::newStream(StreamDecoder& decoder) { - StreamImplPtr stream(new ClientStreamImpl(*this, per_stream_buffer_limit_)); - stream->decoder_ = &decoder; +RequestEncoder& ClientConnectionImpl::newStream(ResponseDecoder& decoder) { + ClientStreamImplPtr stream(new ClientStreamImpl(*this, per_stream_buffer_limit_, decoder)); // If the connection is currently above the high watermark, make sure to inform the new stream. // The connection can not pass this on automatically as it has no awareness that a new stream is // created. if (connection_.aboveHighWatermark()) { stream->runHighWatermarkCallbacks(); } + ClientStreamImpl& stream_ref = *stream; stream->moveIntoList(std::move(stream), active_streams_); - return *active_streams_.front(); + return stream_ref; } int ClientConnectionImpl::onBeginHeaders(const nghttp2_frame* frame) { @@ -1131,11 +1147,11 @@ int ServerConnectionImpl::onBeginHeaders(const nghttp2_frame* frame) { return 0; } - StreamImplPtr stream(new ServerStreamImpl(*this, per_stream_buffer_limit_)); + ServerStreamImplPtr stream(new ServerStreamImpl(*this, per_stream_buffer_limit_)); if (connection_.aboveHighWatermark()) { stream->runHighWatermarkCallbacks(); } - stream->decoder_ = &callbacks_.newStream(*stream); + stream->request_decoder_ = &callbacks_.newStream(*stream); stream->stream_id_ = frame->hd.stream_id; stream->moveIntoList(std::move(stream), active_streams_); nghttp2_session_set_stream_user_data(session_, frame->hd.stream_id, diff --git a/source/common/http/http2/codec_impl.h b/source/common/http/http2/codec_impl.h index c5b8dc1ac8f4..e9390acd3df1 100644 --- a/source/common/http/http2/codec_impl.h +++ b/source/common/http/http2/codec_impl.h @@ -140,7 +140,7 @@ class ConnectionImpl : public virtual Connection, protected Logger::Loggable, public Event::DeferredDeletable, @@ -154,16 +154,16 @@ class ConnectionImpl : public virtual Connection, protected Logger::Loggable& final_headers, const HeaderMap& headers); void saveHeader(HeaderString&& name, HeaderString&& value); + void encodeHeadersBase(const HeaderMap& headers, bool end_stream); virtual void submitHeaders(const std::vector& final_headers, nghttp2_data_provider* provider) PURE; + void encodeTrailersBase(const HeaderMap& headers); void submitTrailers(const HeaderMap& trailers); void submitMetadata(); + virtual StreamDecoder& decoder() PURE; // Http::StreamEncoder - void encode100ContinueHeaders(const HeaderMap& headers) override; - void encodeHeaders(const HeaderMap& headers, bool end_stream) override; void encodeData(Buffer::Instance& data, bool end_stream) override; - void encodeTrailers(const HeaderMap& trailers) override; Stream& getStream() override { return *this; } void encodeMetadata(const MetadataMapVector& metadata_map_vector) override; @@ -193,7 +193,8 @@ class ConnectionImpl : public virtual Connection, protected Logger::Loggable 0; } ConnectionImpl& parent_; HeaderMapImplPtr headers_; - StreamDecoder* decoder_{}; int32_t stream_id_{-1}; uint32_t unconsumed_bytes_{0}; uint32_t read_disable_count_{0}; @@ -238,8 +237,10 @@ class ConnectionImpl : public virtual Connection, protected Logger::Loggable& final_headers, @@ -248,38 +249,52 @@ class ConnectionImpl : public virtual Connection, protected Logger::Loggablevalue().getStringView()); Http::Utility::transformUpgradeRequestFromH1toH2(headers); } - void maybeTransformUpgradeFromH2ToH1() override { - if (!upgrade_type_.empty() && headers_->Status()) { - Http::Utility::transformUpgradeResponseFromH2toH1(*headers_, upgrade_type_); - } + StreamDecoder& decoder() override { return response_decoder_; } + void decodeHeaders() override; + void decodeTrailers() override; + + // RequestEncoder + void encodeHeaders(const HeaderMap& headers, bool end_stream) override { + encodeHeadersBase(headers, end_stream); } + void encodeTrailers(const HeaderMap& trailers) override { encodeTrailersBase(trailers); } + + ResponseDecoder& response_decoder_; std::string upgrade_type_; }; + using ClientStreamImplPtr = std::unique_ptr; + /** * Server side stream (response). */ - struct ServerStreamImpl : public StreamImpl { + struct ServerStreamImpl : public StreamImpl, public ResponseEncoder { using StreamImpl::StreamImpl; // StreamImpl - void encodeHeaders(const HeaderMap& headers, bool end_stream) override { - // The contract is that client codecs must ensure that :status is present. - ASSERT(headers.Status() != nullptr); - StreamImpl::encodeHeaders(headers, end_stream); - } void submitHeaders(const std::vector& final_headers, nghttp2_data_provider* provider) override; void transformUpgradeFromH1toH2(HeaderMap& headers) override { Http::Utility::transformUpgradeResponseFromH1toH2(headers); } - void maybeTransformUpgradeFromH2ToH1() override { - if (Http::Utility::isH2UpgradeRequest(*headers_)) { - Http::Utility::transformUpgradeRequestFromH2toH1(*headers_); - } + StreamDecoder& decoder() override { return *request_decoder_; } + void decodeHeaders() override; + void decodeTrailers() override; + + // ResponseEncoder + void encode100ContinueHeaders(const HeaderMap& headers) override; + void encodeHeaders(const HeaderMap& headers, bool end_stream) override { + // The contract is that client codecs must ensure that :status is present. + ASSERT(headers.Status() != nullptr); + encodeHeadersBase(headers, end_stream); } + void encodeTrailers(const HeaderMap& trailers) override { encodeTrailersBase(trailers); } + + RequestDecoder* request_decoder_{}; }; + using ServerStreamImplPtr = std::unique_ptr; + ConnectionImpl* base() { return this; } StreamImpl* getStream(int32_t stream_id); int saveHeader(const nghttp2_frame* frame, HeaderString&& name, HeaderString&& value); @@ -403,7 +418,7 @@ class ClientConnectionImpl : public ClientConnection, public ConnectionImpl { const uint32_t max_response_headers_count); // Http::ClientConnection - Http::StreamEncoder& newStream(StreamDecoder& response_decoder) override; + RequestEncoder& newStream(ResponseDecoder& response_decoder) override; private: // ConnectionImpl diff --git a/source/common/http/http2/conn_pool.cc b/source/common/http/http2/conn_pool.cc index 2fc988a8fe64..090ac7d4d1de 100644 --- a/source/common/http/http2/conn_pool.cc +++ b/source/common/http/http2/conn_pool.cc @@ -82,7 +82,7 @@ bool ConnPoolImpl::ActiveClient::closingWithIncompleteRequest() const { return closed_with_active_rq_; } -StreamEncoder& ConnPoolImpl::ActiveClient::newStreamEncoder(StreamDecoder& response_decoder) { +RequestEncoder& ConnPoolImpl::ActiveClient::newStreamEncoder(ResponseDecoder& response_decoder) { return codec_client_->newStream(response_decoder); } diff --git a/source/common/http/http2/conn_pool.h b/source/common/http/http2/conn_pool.h index 30685c9a37f8..481f4eb24a97 100644 --- a/source/common/http/http2/conn_pool.h +++ b/source/common/http/http2/conn_pool.h @@ -43,7 +43,7 @@ class ConnPoolImpl : public ConnPoolImplBase { // ConnPoolImpl::ActiveClient bool hasActiveRequests() const override; bool closingWithIncompleteRequest() const override; - StreamEncoder& newStreamEncoder(StreamDecoder& response_decoder) override; + RequestEncoder& newStreamEncoder(ResponseDecoder& response_decoder) override; // CodecClientCallbacks void onStreamDestroy() override { parent().onStreamDestroy(*this); } diff --git a/source/common/http/http2/conn_pool_legacy.cc b/source/common/http/http2/conn_pool_legacy.cc index 9e4c271fd6a5..c949459d548b 100644 --- a/source/common/http/http2/conn_pool_legacy.cc +++ b/source/common/http/http2/conn_pool_legacy.cc @@ -87,7 +87,7 @@ void ConnPoolImpl::checkForDrained() { } } -void ConnPoolImpl::newClientStream(Http::StreamDecoder& response_decoder, +void ConnPoolImpl::newClientStream(ResponseDecoder& response_decoder, ConnectionPool::Callbacks& callbacks) { if (!host_->cluster().resourceManager(priority_).requests().canCreate()) { ENVOY_LOG(debug, "max requests overflow"); @@ -108,7 +108,7 @@ void ConnPoolImpl::newClientStream(Http::StreamDecoder& response_decoder, } } -ConnectionPool::Cancellable* ConnPoolImpl::newStream(Http::StreamDecoder& response_decoder, +ConnectionPool::Cancellable* ConnPoolImpl::newStream(ResponseDecoder& response_decoder, ConnectionPool::Callbacks& callbacks) { ASSERT(drained_callbacks_.empty()); diff --git a/source/common/http/http2/conn_pool_legacy.h b/source/common/http/http2/conn_pool_legacy.h index 6fef4d989de0..0ffb2e520a8d 100644 --- a/source/common/http/http2/conn_pool_legacy.h +++ b/source/common/http/http2/conn_pool_legacy.h @@ -36,7 +36,7 @@ class ConnPoolImpl : public ConnectionPool::Instance, public Legacy::ConnPoolImp void addDrainedCallback(DrainedCb cb) override; void drainConnections() override; bool hasActiveConnections() const override; - ConnectionPool::Cancellable* newStream(Http::StreamDecoder& response_decoder, + ConnectionPool::Cancellable* newStream(ResponseDecoder& response_decoder, ConnectionPool::Callbacks& callbacks) override; Upstream::HostDescriptionConstSharedPtr host() const override { return host_; }; @@ -88,7 +88,7 @@ class ConnPoolImpl : public ConnectionPool::Instance, public Legacy::ConnPoolImp void onGoAway(ActiveClient& client); void onStreamDestroy(ActiveClient& client); void onStreamReset(ActiveClient& client, Http::StreamResetReason reason); - void newClientStream(Http::StreamDecoder& response_decoder, ConnectionPool::Callbacks& callbacks); + void newClientStream(ResponseDecoder& response_decoder, ConnectionPool::Callbacks& callbacks); void onUpstreamReady(); Event::Dispatcher& dispatcher_; diff --git a/source/common/router/router.cc b/source/common/router/router.cc index 7823c3c2fcec..5c54c8e2905b 100644 --- a/source/common/router/router.cc +++ b/source/common/router/router.cc @@ -1697,7 +1697,7 @@ void Filter::UpstreamRequest::onPoolFailure(Http::ConnectionPool::PoolFailureRea onResetStream(reset_reason, transport_failure_reason); } -void Filter::UpstreamRequest::onPoolReady(Http::StreamEncoder& request_encoder, +void Filter::UpstreamRequest::onPoolReady(Http::RequestEncoder& request_encoder, Upstream::HostDescriptionConstSharedPtr host, const StreamInfo::StreamInfo& info) { // This may be called under an existing ScopeTrackerScopeState but it will unwind correctly. @@ -1787,7 +1787,7 @@ ProdFilter::createRetryState(const RetryPolicy& policy, Http::HeaderMap& request priority); } -void Filter::UpstreamRequest::setRequestEncoder(Http::StreamEncoder& request_encoder) { +void Filter::UpstreamRequest::setRequestEncoder(Http::RequestEncoder& request_encoder) { request_encoder_ = &request_encoder; // Now that there is an encoder, have the connection manager inform the manager when the // downstream buffers are overrun. This may result in immediate watermark callbacks referencing diff --git a/source/common/router/router.h b/source/common/router/router.h index b21ec0b4846d..8674b6ac21cd 100644 --- a/source/common/router/router.h +++ b/source/common/router/router.h @@ -366,7 +366,7 @@ class Filter : Logger::Loggable, RetryStatePtr retry_state_; private: - struct UpstreamRequest : public Http::StreamDecoder, + struct UpstreamRequest : public Http::ResponseDecoder, public Http::StreamCallbacks, public Http::ConnectionPool::Callbacks, public LinkedObject { @@ -393,11 +393,13 @@ class Filter : Logger::Loggable, } // Http::StreamDecoder + void decodeData(Buffer::Instance& data, bool end_stream) override; + void decodeMetadata(Http::MetadataMapPtr&& metadata_map) override; + + // Http::ResponseDecoder void decode100ContinueHeaders(Http::HeaderMapPtr&& headers) override; void decodeHeaders(Http::HeaderMapPtr&& headers, bool end_stream) override; - void decodeData(Buffer::Instance& data, bool end_stream) override; void decodeTrailers(Http::HeaderMapPtr&& trailers) override; - void decodeMetadata(Http::MetadataMapPtr&& metadata_map) override; // Http::StreamCallbacks void onResetStream(Http::StreamResetReason reason, @@ -439,11 +441,11 @@ class Filter : Logger::Loggable, void onPoolFailure(Http::ConnectionPool::PoolFailureReason reason, absl::string_view transport_failure_reason, Upstream::HostDescriptionConstSharedPtr host) override; - void onPoolReady(Http::StreamEncoder& request_encoder, + void onPoolReady(Http::RequestEncoder& request_encoder, Upstream::HostDescriptionConstSharedPtr host, const StreamInfo::StreamInfo& info) override; - void setRequestEncoder(Http::StreamEncoder& request_encoder); + void setRequestEncoder(Http::RequestEncoder& request_encoder); void clearRequestEncoder(); struct DownstreamWatermarkManager : public Http::DownstreamWatermarkCallbacks { @@ -463,7 +465,7 @@ class Filter : Logger::Loggable, bool grpc_rq_success_deferred_; Event::TimerPtr per_try_timeout_; Http::ConnectionPool::Cancellable* conn_pool_stream_handle_{}; - Http::StreamEncoder* request_encoder_{}; + Http::RequestEncoder* request_encoder_{}; absl::optional deferred_reset_reason_; Buffer::WatermarkBufferPtr buffered_request_body_; Upstream::HostDescriptionConstSharedPtr upstream_host_; diff --git a/source/common/upstream/health_checker_impl.cc b/source/common/upstream/health_checker_impl.cc index e5c279cd99de..74a528886713 100644 --- a/source/common/upstream/health_checker_impl.cc +++ b/source/common/upstream/health_checker_impl.cc @@ -228,7 +228,7 @@ void HttpHealthCheckerImpl::HttpActiveHealthCheckSession::onInterval() { expect_reset_ = false; } - Http::StreamEncoder* request_encoder = &client_->newStream(*this); + Http::RequestEncoder* request_encoder = &client_->newStream(*this); request_encoder->getStream().addCallbacks(*this); Http::HeaderMapImpl request_headers{ diff --git a/source/common/upstream/health_checker_impl.h b/source/common/upstream/health_checker_impl.h index 6f2b1ed2298a..4976f563b852 100644 --- a/source/common/upstream/health_checker_impl.h +++ b/source/common/upstream/health_checker_impl.h @@ -69,7 +69,7 @@ class HttpHealthCheckerImpl : public HealthCheckerImplBase { private: struct HttpActiveHealthCheckSession : public ActiveHealthCheckSession, - public Http::StreamDecoder, + public Http::ResponseDecoder, public Http::StreamCallbacks { HttpActiveHealthCheckSession(HttpHealthCheckerImpl& parent, const HostSharedPtr& host); ~HttpActiveHealthCheckSession() override; @@ -85,16 +85,18 @@ class HttpHealthCheckerImpl : public HealthCheckerImplBase { void onDeferredDelete() final; // Http::StreamDecoder - void decode100ContinueHeaders(Http::HeaderMapPtr&&) override {} - void decodeHeaders(Http::HeaderMapPtr&& headers, bool end_stream) override; void decodeData(Buffer::Instance&, bool end_stream) override { if (end_stream) { onResponseComplete(); } } - void decodeTrailers(Http::HeaderMapPtr&&) override { onResponseComplete(); } void decodeMetadata(Http::MetadataMapPtr&&) override {} + // Http::ResponseDecoder + void decode100ContinueHeaders(Http::HeaderMapPtr&&) override {} + void decodeHeaders(Http::HeaderMapPtr&& headers, bool end_stream) override; + void decodeTrailers(Http::HeaderMapPtr&&) override { onResponseComplete(); } + // Http::StreamCallbacks void onResetStream(Http::StreamResetReason reason, absl::string_view transport_failure_reason) override; @@ -288,7 +290,7 @@ class GrpcHealthCheckerImpl : public HealthCheckerImplBase { private: struct GrpcActiveHealthCheckSession : public ActiveHealthCheckSession, - public Http::StreamDecoder, + public Http::ResponseDecoder, public Http::StreamCallbacks { GrpcActiveHealthCheckSession(GrpcHealthCheckerImpl& parent, const HostSharedPtr& host); ~GrpcActiveHealthCheckSession() override; @@ -306,11 +308,13 @@ class GrpcHealthCheckerImpl : public HealthCheckerImplBase { void onDeferredDelete() final; // Http::StreamDecoder + void decodeData(Buffer::Instance&, bool end_stream) override; + void decodeMetadata(Http::MetadataMapPtr&&) override {} + + // Http::ResponseDecoder void decode100ContinueHeaders(Http::HeaderMapPtr&&) override {} void decodeHeaders(Http::HeaderMapPtr&& headers, bool end_stream) override; - void decodeData(Buffer::Instance&, bool end_stream) override; void decodeTrailers(Http::HeaderMapPtr&&) override; - void decodeMetadata(Http::MetadataMapPtr&&) override {} // Http::StreamCallbacks void onResetStream(Http::StreamResetReason reason, @@ -347,7 +351,7 @@ class GrpcHealthCheckerImpl : public HealthCheckerImplBase { HttpConnectionCallbackImpl http_connection_callback_impl_{*this}; GrpcHealthCheckerImpl& parent_; Http::CodecClientPtr client_; - Http::StreamEncoder* request_encoder_; + Http::RequestEncoder* request_encoder_; Grpc::Decoder decoder_; std::unique_ptr health_check_response_; // If true, stream reset was initiated by us (GrpcActiveHealthCheckSession), not by HTTP stack, diff --git a/source/extensions/quic_listeners/quiche/codec_impl.cc b/source/extensions/quic_listeners/quiche/codec_impl.cc index 49b7128aaa3a..fc031eb32dbe 100644 --- a/source/extensions/quic_listeners/quiche/codec_impl.cc +++ b/source/extensions/quic_listeners/quiche/codec_impl.cc @@ -12,6 +12,9 @@ namespace Quic { EnvoyQuicStream* quicStreamToEnvoyStream(quic::QuicStream* stream) { return dynamic_cast(stream); } +EnvoyQuicClientStream* quicStreamToEnvoyClientStream(quic::QuicStream* stream) { + return dynamic_cast(stream); +} bool QuicHttpConnectionImplBase::wantsToWrite() { return quic_session_.bytesToSend() > 0; } @@ -58,15 +61,15 @@ QuicHttpClientConnectionImpl::QuicHttpClientConnectionImpl(EnvoyQuicClientSessio session.setHttpConnectionCallbacks(callbacks); } -Http::StreamEncoder& -QuicHttpClientConnectionImpl::newStream(Http::StreamDecoder& response_decoder) { - EnvoyQuicStream* stream = - quicStreamToEnvoyStream(quic_client_session_.CreateOutgoingBidirectionalStream()); +Http::RequestEncoder& +QuicHttpClientConnectionImpl::newStream(Http::ResponseDecoder& response_decoder) { + EnvoyQuicClientStream* stream = + quicStreamToEnvoyClientStream(quic_client_session_.CreateOutgoingBidirectionalStream()); // TODO(danzh) handle stream creation failure gracefully. This can happen when // there are already 100 open streams. In such case, caller should hold back // the stream creation till an existing stream is closed. ASSERT(stream != nullptr, "Fail to create QUIC stream."); - stream->setDecoder(response_decoder); + stream->setResponseDecoder(response_decoder); if (quic_client_session_.aboveHighWatermark()) { stream->runHighWatermarkCallbacks(); } diff --git a/source/extensions/quic_listeners/quiche/codec_impl.h b/source/extensions/quic_listeners/quiche/codec_impl.h index 3fabff7c3ae5..732a8aa8e5ab 100644 --- a/source/extensions/quic_listeners/quiche/codec_impl.h +++ b/source/extensions/quic_listeners/quiche/codec_impl.h @@ -65,7 +65,7 @@ class QuicHttpClientConnectionImpl : public QuicHttpConnectionImplBase, Http::ConnectionCallbacks& callbacks); // Http::ClientConnection - Http::StreamEncoder& newStream(Http::StreamDecoder& response_decoder) override; + Http::RequestEncoder& newStream(Http::ResponseDecoder& response_decoder) override; // Http::Connection void goAway() override { NOT_REACHED_GCOVR_EXCL_LINE; } diff --git a/source/extensions/quic_listeners/quiche/envoy_quic_client_stream.cc b/source/extensions/quic_listeners/quiche/envoy_quic_client_stream.cc index b6fed6f10833..c70228d0e07c 100644 --- a/source/extensions/quic_listeners/quiche/envoy_quic_client_stream.cc +++ b/source/extensions/quic_listeners/quiche/envoy_quic_client_stream.cc @@ -44,11 +44,6 @@ EnvoyQuicClientStream::EnvoyQuicClientStream(quic::PendingStream* pending, 16 * 1024, [this]() { runLowWatermarkCallbacks(); }, [this]() { runHighWatermarkCallbacks(); }) {} -void EnvoyQuicClientStream::encode100ContinueHeaders(const Http::HeaderMap& headers) { - ASSERT(headers.Status()->value() == "100"); - encodeHeaders(headers, false); -} - void EnvoyQuicClientStream::encodeHeaders(const Http::HeaderMap& headers, bool end_stream) { ENVOY_STREAM_LOG(debug, "encodeHeaders: (end_stream={}) {}.", *this, end_stream, headers); WriteHeaders(envoyHeadersToSpdyHeaderBlock(headers), end_stream, nullptr); @@ -109,9 +104,8 @@ void EnvoyQuicClientStream::OnInitialHeadersComplete(bool fin, size_t frame_len, if (rst_sent()) { return; } - ASSERT(decoder() != nullptr); ASSERT(headers_decompressed()); - decoder()->decodeHeaders(quicHeadersToEnvoyHeaders(header_list), /*end_stream=*/fin); + response_decoder_->decodeHeaders(quicHeadersToEnvoyHeaders(header_list), /*end_stream=*/fin); if (fin) { end_stream_decoded_ = true; } @@ -150,7 +144,7 @@ void EnvoyQuicClientStream::OnBodyAvailable() { // already delivered it or decodeTrailers will be called. bool skip_decoding = empty_payload_with_fin && (end_stream_decoded_ || !finished_reading); if (!skip_decoding) { - decoder()->decodeData(*buffer, finished_reading); + response_decoder_->decodeData(*buffer, finished_reading); if (finished_reading) { end_stream_decoded_ = true; } @@ -170,7 +164,7 @@ void EnvoyQuicClientStream::OnBodyAvailable() { // For Google QUIC implementation, trailers may arrived earlier and wait to // be consumed after reading all the body. Consume it here. // IETF QUIC shouldn't reach here because trailers are sent on same stream. - decoder()->decodeTrailers(spdyHeaderBlockToEnvoyHeaders(received_trailers())); + response_decoder_->decodeTrailers(spdyHeaderBlockToEnvoyHeaders(received_trailers())); MarkTrailersConsumed(); } OnFinRead(); @@ -186,8 +180,7 @@ void EnvoyQuicClientStream::OnTrailingHeadersComplete(bool fin, size_t frame_len !FinishedReadingTrailers()) { // Before QPack, trailers can arrive before body. Only decode trailers after finishing decoding // body. - ASSERT(decoder() != nullptr); - decoder()->decodeTrailers(spdyHeaderBlockToEnvoyHeaders(received_trailers())); + response_decoder_->decodeTrailers(spdyHeaderBlockToEnvoyHeaders(received_trailers())); MarkTrailersConsumed(); } } diff --git a/source/extensions/quic_listeners/quiche/envoy_quic_client_stream.h b/source/extensions/quic_listeners/quiche/envoy_quic_client_stream.h index 6f99a8098041..b2f420c41c86 100644 --- a/source/extensions/quic_listeners/quiche/envoy_quic_client_stream.h +++ b/source/extensions/quic_listeners/quiche/envoy_quic_client_stream.h @@ -15,20 +15,25 @@ namespace Envoy { namespace Quic { // This class is a quic stream and also a request encoder. -class EnvoyQuicClientStream : public quic::QuicSpdyClientStream, public EnvoyQuicStream { +class EnvoyQuicClientStream : public quic::QuicSpdyClientStream, + public EnvoyQuicStream, + public Http::RequestEncoder { public: EnvoyQuicClientStream(quic::QuicStreamId id, quic::QuicSpdyClientSession* client_session, quic::StreamType type); EnvoyQuicClientStream(quic::PendingStream* pending, quic::QuicSpdyClientSession* client_session, quic::StreamType type); + void setResponseDecoder(Http::ResponseDecoder& decoder) { response_decoder_ = &decoder; } + // Http::StreamEncoder - void encode100ContinueHeaders(const Http::HeaderMap& headers) override; - void encodeHeaders(const Http::HeaderMap& headers, bool end_stream) override; void encodeData(Buffer::Instance& data, bool end_stream) override; - void encodeTrailers(const Http::HeaderMap& trailers) override; void encodeMetadata(const Http::MetadataMapVector& metadata_map_vector) override; + // Http::RequestEncoder + void encodeHeaders(const Http::HeaderMap& headers, bool end_stream) override; + void encodeTrailers(const Http::HeaderMap& trailers) override; + // Http::Stream void resetStream(Http::StreamResetReason reason) override; // quic::QuicSpdyStream @@ -54,6 +59,8 @@ class EnvoyQuicClientStream : public quic::QuicSpdyClientStream, public EnvoyQui private: QuicFilterManagerConnectionImpl* filterManagerConnection(); + + Http::ResponseDecoder* response_decoder_{nullptr}; }; } // namespace Quic diff --git a/source/extensions/quic_listeners/quiche/envoy_quic_server_session.cc b/source/extensions/quic_listeners/quiche/envoy_quic_server_session.cc index d5ba4433fe08..77457350d4d5 100644 --- a/source/extensions/quic_listeners/quiche/envoy_quic_server_session.cc +++ b/source/extensions/quic_listeners/quiche/envoy_quic_server_session.cc @@ -70,10 +70,10 @@ quic::QuicSpdyStream* EnvoyQuicServerSession::CreateOutgoingUnidirectionalStream NOT_REACHED_GCOVR_EXCL_LINE; } -void EnvoyQuicServerSession::setUpRequestDecoder(EnvoyQuicStream& stream) { +void EnvoyQuicServerSession::setUpRequestDecoder(EnvoyQuicServerStream& stream) { ASSERT(http_connection_callbacks_ != nullptr); - Http::StreamDecoder& decoder = http_connection_callbacks_->newStream(stream); - stream.setDecoder(decoder); + Http::RequestDecoder& decoder = http_connection_callbacks_->newStream(stream); + stream.setRequestDecoder(decoder); } void EnvoyQuicServerSession::OnConnectionClosed(const quic::QuicConnectionCloseFrame& frame, diff --git a/source/extensions/quic_listeners/quiche/envoy_quic_server_session.h b/source/extensions/quic_listeners/quiche/envoy_quic_server_session.h index 0e6415e0df2f..50d348fb5f5a 100644 --- a/source/extensions/quic_listeners/quiche/envoy_quic_server_session.h +++ b/source/extensions/quic_listeners/quiche/envoy_quic_server_session.h @@ -14,7 +14,7 @@ #include #include "extensions/quic_listeners/quiche/quic_filter_manager_connection_impl.h" -#include "extensions/quic_listeners/quiche/envoy_quic_stream.h" +#include "extensions/quic_listeners/quiche/envoy_quic_server_stream.h" namespace Envoy { namespace Quic { @@ -73,7 +73,7 @@ class EnvoyQuicServerSession : public quic::QuicServerSessionBase, bool hasDataToWrite() override; private: - void setUpRequestDecoder(EnvoyQuicStream& stream); + void setUpRequestDecoder(EnvoyQuicServerStream& stream); std::unique_ptr quic_connection_; // These callbacks are owned by network filters and quic session should out live diff --git a/source/extensions/quic_listeners/quiche/envoy_quic_server_stream.cc b/source/extensions/quic_listeners/quiche/envoy_quic_server_stream.cc index ca3ff13ca47e..35878eeb3437 100644 --- a/source/extensions/quic_listeners/quiche/envoy_quic_server_stream.cc +++ b/source/extensions/quic_listeners/quiche/envoy_quic_server_stream.cc @@ -126,9 +126,8 @@ void EnvoyQuicServerStream::switchStreamBlockState(bool should_block) { void EnvoyQuicServerStream::OnInitialHeadersComplete(bool fin, size_t frame_len, const quic::QuicHeaderList& header_list) { quic::QuicSpdyServerStreamBase::OnInitialHeadersComplete(fin, frame_len, header_list); - ASSERT(decoder() != nullptr); ASSERT(headers_decompressed()); - decoder()->decodeHeaders(quicHeadersToEnvoyHeaders(header_list), /*end_stream=*/fin); + request_decoder_->decodeHeaders(quicHeadersToEnvoyHeaders(header_list), /*end_stream=*/fin); if (fin) { end_stream_decoded_ = true; } @@ -167,8 +166,7 @@ void EnvoyQuicServerStream::OnBodyAvailable() { // already delivered it or decodeTrailers will be called. bool skip_decoding = empty_payload_with_fin && (end_stream_decoded_ || !finished_reading); if (!skip_decoding) { - ASSERT(decoder() != nullptr); - decoder()->decodeData(*buffer, finished_reading); + request_decoder_->decodeData(*buffer, finished_reading); if (finished_reading) { end_stream_decoded_ = true; } @@ -188,7 +186,7 @@ void EnvoyQuicServerStream::OnBodyAvailable() { // For Google QUIC implementation, trailers may arrived earlier and wait to // be consumed after reading all the body. Consume it here. // IETF QUIC shouldn't reach here because trailers are sent on same stream. - decoder()->decodeTrailers(spdyHeaderBlockToEnvoyHeaders(received_trailers())); + request_decoder_->decodeTrailers(spdyHeaderBlockToEnvoyHeaders(received_trailers())); MarkTrailersConsumed(); } OnFinRead(); @@ -203,8 +201,7 @@ void EnvoyQuicServerStream::OnTrailingHeadersComplete(bool fin, size_t frame_len !FinishedReadingTrailers()) { // Before QPack trailers can arrive before body. Only decode trailers after finishing decoding // body. - ASSERT(decoder() != nullptr); - decoder()->decodeTrailers(spdyHeaderBlockToEnvoyHeaders(received_trailers())); + request_decoder_->decodeTrailers(spdyHeaderBlockToEnvoyHeaders(received_trailers())); MarkTrailersConsumed(); } } diff --git a/source/extensions/quic_listeners/quiche/envoy_quic_server_stream.h b/source/extensions/quic_listeners/quiche/envoy_quic_server_stream.h index e79ac3d081ed..80353f2cd1b7 100644 --- a/source/extensions/quic_listeners/quiche/envoy_quic_server_stream.h +++ b/source/extensions/quic_listeners/quiche/envoy_quic_server_stream.h @@ -15,7 +15,9 @@ namespace Envoy { namespace Quic { // This class is a quic stream and also a response encoder. -class EnvoyQuicServerStream : public quic::QuicSpdyServerStreamBase, public EnvoyQuicStream { +class EnvoyQuicServerStream : public quic::QuicSpdyServerStreamBase, + public EnvoyQuicStream, + public Http::ResponseEncoder { public: EnvoyQuicServerStream(quic::QuicStreamId id, quic::QuicSpdySession* session, quic::StreamType type); @@ -23,6 +25,8 @@ class EnvoyQuicServerStream : public quic::QuicSpdyServerStreamBase, public Envo EnvoyQuicServerStream(quic::PendingStream* pending, quic::QuicSpdySession* session, quic::StreamType type); + void setRequestDecoder(Http::RequestDecoder& decoder) { request_decoder_ = &decoder; } + // Http::StreamEncoder void encode100ContinueHeaders(const Http::HeaderMap& headers) override; void encodeHeaders(const Http::HeaderMap& headers, bool end_stream) override; @@ -54,6 +58,8 @@ class EnvoyQuicServerStream : public quic::QuicSpdyServerStreamBase, public Envo private: QuicFilterManagerConnectionImpl* filterManagerConnection(); + + Http::RequestDecoder* request_decoder_{nullptr}; }; } // namespace Quic diff --git a/source/extensions/quic_listeners/quiche/envoy_quic_stream.h b/source/extensions/quic_listeners/quiche/envoy_quic_stream.h index 157422ecc505..7171473e322c 100644 --- a/source/extensions/quic_listeners/quiche/envoy_quic_stream.h +++ b/source/extensions/quic_listeners/quiche/envoy_quic_stream.h @@ -12,7 +12,7 @@ namespace Envoy { namespace Quic { // Base class for EnvoyQuicServer|ClientStream. -class EnvoyQuicStream : public Http::StreamEncoder, +class EnvoyQuicStream : public virtual Http::StreamEncoder, public Http::Stream, public Http::StreamCallbackHelper, protected Logger::Loggable { @@ -80,10 +80,6 @@ class EnvoyQuicStream : public Http::StreamEncoder, return connection()->localAddress(); } - // Needs to be called during quic stream creation before the stream receives - // any headers and data. - void setDecoder(Http::StreamDecoder& decoder) { decoder_ = &decoder; } - void maybeCheckWatermark(uint64_t buffered_data_old, uint64_t buffered_data_new, QuicFilterManagerConnectionImpl& connection) { if (buffered_data_new == buffered_data_old) { @@ -106,11 +102,6 @@ class EnvoyQuicStream : public Http::StreamEncoder, virtual uint32_t streamId() PURE; virtual Network::Connection* connection() PURE; - Http::StreamDecoder* decoder() { - ASSERT(decoder_ != nullptr); - return decoder_; - } - // True once end of stream is propagated to Envoy. Envoy doesn't expect to be // notified more than once about end of stream. So once this is true, no need // to set it in the callback to Envoy stream any more. @@ -121,8 +112,6 @@ class EnvoyQuicStream : public Http::StreamEncoder, bool in_decode_data_callstack_{false}; private: - // Not owned. - Http::StreamDecoder* decoder_{nullptr}; // Keeps track of bytes buffered in the stream send buffer in QUICHE and reacts // upon crossing high and low watermarks. // Its high watermark is also the buffer limit of stream read/write filters in diff --git a/test/common/http/async_client_impl_test.cc b/test/common/http/async_client_impl_test.cc index b2e66ca01033..e4a0f6323192 100644 --- a/test/common/http/async_client_impl_test.cc +++ b/test/common/http/async_client_impl_test.cc @@ -71,8 +71,8 @@ class AsyncClientImplTest : public testing::Test { MockAsyncClientCallbacks callbacks_; MockAsyncClientStreamCallbacks stream_callbacks_; NiceMock cm_; - NiceMock stream_encoder_; - StreamDecoder* response_decoder_{}; + NiceMock stream_encoder_; + ResponseDecoder* response_decoder_{}; NiceMock* timer_; NiceMock dispatcher_; NiceMock runtime_; @@ -93,7 +93,7 @@ TEST_F(AsyncClientImplTest, BasicStream) { Buffer::InstancePtr body{new Buffer::OwnedImpl("test body")}; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -136,7 +136,7 @@ TEST_F(AsyncClientImplTest, Basic) { Buffer::Instance& data = *message_->body(); EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -172,7 +172,7 @@ TEST_F(AsyncClientImplTracingTest, Basic) { Buffer::Instance& data = *message_->body(); EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -211,7 +211,7 @@ TEST_F(AsyncClientImplTracingTest, BasicNamedChildSpan) { Buffer::Instance& data = *message_->body(); EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -249,7 +249,7 @@ TEST_F(AsyncClientImplTest, BasicHashPolicy) { Buffer::Instance& data = *message_->body(); EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -293,7 +293,7 @@ TEST_F(AsyncClientImplTest, Retry) { Buffer::Instance& data = *message_->body(); EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -313,7 +313,7 @@ TEST_F(AsyncClientImplTest, Retry) { // Retry request. EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -336,7 +336,7 @@ TEST_F(AsyncClientImplTest, RetryWithStream) { Buffer::InstancePtr body{new Buffer::OwnedImpl("test body")}; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -361,7 +361,7 @@ TEST_F(AsyncClientImplTest, RetryWithStream) { // Retry request. EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -384,7 +384,7 @@ TEST_F(AsyncClientImplTest, MultipleStreams) { Buffer::InstancePtr body{new Buffer::OwnedImpl("test body")}; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -405,12 +405,12 @@ TEST_F(AsyncClientImplTest, MultipleStreams) { // Start stream 2 Buffer::InstancePtr body2{new Buffer::OwnedImpl("test body")}; - NiceMock stream_encoder2; - StreamDecoder* response_decoder2{}; + NiceMock stream_encoder2; + ResponseDecoder* response_decoder2{}; MockAsyncClientStreamCallbacks stream_callbacks2; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder2, cm_.conn_pool_.host_, stream_info_); response_decoder2 = &decoder; @@ -444,7 +444,7 @@ TEST_F(AsyncClientImplTest, MultipleRequests) { Buffer::Instance& data = *message_->body(); EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -459,11 +459,11 @@ TEST_F(AsyncClientImplTest, MultipleRequests) { // Send request 2. MessagePtr message2{new RequestMessageImpl()}; HttpTestUtility::addDefaultHeaders(message2->headers()); - NiceMock stream_encoder2; - StreamDecoder* response_decoder2{}; + NiceMock stream_encoder2; + ResponseDecoder* response_decoder2{}; MockAsyncClientCallbacks callbacks2; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder2, cm_.conn_pool_.host_, stream_info_); response_decoder2 = &decoder; @@ -490,7 +490,7 @@ TEST_F(AsyncClientImplTest, StreamAndRequest) { Buffer::Instance& data = *message_->body(); EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -504,11 +504,11 @@ TEST_F(AsyncClientImplTest, StreamAndRequest) { // Start stream Buffer::InstancePtr body{new Buffer::OwnedImpl("test body")}; - NiceMock stream_encoder2; - StreamDecoder* response_decoder2{}; + NiceMock stream_encoder2; + ResponseDecoder* response_decoder2{}; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder2, cm_.conn_pool_.host_, stream_info_); response_decoder2 = &decoder; @@ -547,7 +547,7 @@ TEST_F(AsyncClientImplTest, StreamWithTrailers) { TestHeaderMapImpl trailers{{"some", "request_trailer"}}; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -580,7 +580,7 @@ TEST_F(AsyncClientImplTest, Trailers) { Buffer::Instance& data = *message_->body(); EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -621,7 +621,7 @@ TEST_F(AsyncClientImplTest, LocalResetAfterStreamStart) { Buffer::InstancePtr body{new Buffer::OwnedImpl("test body")}; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -656,7 +656,7 @@ TEST_F(AsyncClientImplTest, SendDataAfterRemoteClosure) { Buffer::InstancePtr body{new Buffer::OwnedImpl("test body")}; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -690,7 +690,7 @@ TEST_F(AsyncClientImplTest, SendTrailersRemoteClosure) { Buffer::InstancePtr body{new Buffer::OwnedImpl("test body")}; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -764,7 +764,7 @@ TEST_F(AsyncClientImplTest, RemoteResetAfterStreamStart) { Buffer::InstancePtr body{new Buffer::OwnedImpl("test body")}; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -797,7 +797,7 @@ TEST_F(AsyncClientImplTest, RemoteResetAfterStreamStart) { TEST_F(AsyncClientImplTest, ResetAfterResponseStart) { EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; @@ -1135,7 +1135,7 @@ TEST_F(AsyncClientImplTest, MultipleDataStream) { Buffer::InstancePtr body2{new Buffer::OwnedImpl("test body2")}; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](StreamDecoder& decoder, + .WillOnce(Invoke([&](ResponseDecoder& decoder, ConnectionPool::Callbacks& callbacks) -> ConnectionPool::Cancellable* { callbacks.onPoolReady(stream_encoder_, cm_.conn_pool_.host_, stream_info_); response_decoder_ = &decoder; diff --git a/test/common/http/codec_client_test.cc b/test/common/http/codec_client_test.cc index 8aa90954b2de..e8876f8c3109 100644 --- a/test/common/http/codec_client_test.cc +++ b/test/common/http/codec_client_test.cc @@ -90,15 +90,15 @@ TEST_F(CodecClientTest, NotCallDetectEarlyCloseWhenReadDiabledUsingHttp3) { } TEST_F(CodecClientTest, BasicHeaderOnlyResponse) { - Http::StreamDecoder* inner_decoder; - NiceMock inner_encoder; + ResponseDecoder* inner_decoder; + NiceMock inner_encoder; EXPECT_CALL(*codec_, newStream(_)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder) -> Http::StreamEncoder& { + .WillOnce(Invoke([&](ResponseDecoder& decoder) -> RequestEncoder& { inner_decoder = &decoder; return inner_encoder; })); - Http::MockStreamDecoder outer_decoder; + Http::MockResponseDecoder outer_decoder; client_->newStream(outer_decoder); Http::HeaderMapPtr response_headers{new TestHeaderMapImpl{{":status", "200"}}}; @@ -107,15 +107,15 @@ TEST_F(CodecClientTest, BasicHeaderOnlyResponse) { } TEST_F(CodecClientTest, BasicResponseWithBody) { - Http::StreamDecoder* inner_decoder; - NiceMock inner_encoder; + ResponseDecoder* inner_decoder; + NiceMock inner_encoder; EXPECT_CALL(*codec_, newStream(_)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder) -> Http::StreamEncoder& { + .WillOnce(Invoke([&](ResponseDecoder& decoder) -> RequestEncoder& { inner_decoder = &decoder; return inner_encoder; })); - Http::MockStreamDecoder outer_decoder; + Http::MockResponseDecoder outer_decoder; client_->newStream(outer_decoder); Http::HeaderMapPtr response_headers{new TestHeaderMapImpl{{":status", "200"}}}; @@ -128,15 +128,15 @@ TEST_F(CodecClientTest, BasicResponseWithBody) { } TEST_F(CodecClientTest, DisconnectBeforeHeaders) { - Http::StreamDecoder* inner_decoder; - NiceMock inner_encoder; + ResponseDecoder* inner_decoder; + NiceMock inner_encoder; EXPECT_CALL(*codec_, newStream(_)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder) -> Http::StreamEncoder& { + .WillOnce(Invoke([&](ResponseDecoder& decoder) -> RequestEncoder& { inner_decoder = &decoder; return inner_encoder; })); - Http::MockStreamDecoder outer_decoder; + Http::MockResponseDecoder outer_decoder; Http::StreamEncoder& request_encoder = client_->newStream(outer_decoder); Http::MockStreamCallbacks callbacks; request_encoder.getStream().addCallbacks(callbacks); @@ -150,15 +150,15 @@ TEST_F(CodecClientTest, DisconnectBeforeHeaders) { } TEST_F(CodecClientTest, IdleTimerWithNoActiveRequests) { - Http::StreamDecoder* inner_decoder; - NiceMock inner_encoder; + ResponseDecoder* inner_decoder; + NiceMock inner_encoder; EXPECT_CALL(*codec_, newStream(_)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder) -> Http::StreamEncoder& { + .WillOnce(Invoke([&](ResponseDecoder& decoder) -> RequestEncoder& { inner_decoder = &decoder; return inner_encoder; })); - Http::MockStreamDecoder outer_decoder; + Http::MockResponseDecoder outer_decoder; Http::StreamEncoder& request_encoder = client_->newStream(outer_decoder); Http::MockStreamCallbacks callbacks; request_encoder.getStream().addCallbacks(callbacks); @@ -182,15 +182,15 @@ TEST_F(CodecClientTest, IdleTimerWithNoActiveRequests) { } TEST_F(CodecClientTest, IdleTimerClientRemoteCloseWithActiveRequests) { - Http::StreamDecoder* inner_decoder; - NiceMock inner_encoder; + ResponseDecoder* inner_decoder; + NiceMock inner_encoder; EXPECT_CALL(*codec_, newStream(_)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder) -> Http::StreamEncoder& { + .WillOnce(Invoke([&](ResponseDecoder& decoder) -> RequestEncoder& { inner_decoder = &decoder; return inner_encoder; })); - Http::MockStreamDecoder outer_decoder; + Http::MockResponseDecoder outer_decoder; Http::StreamEncoder& request_encoder = client_->newStream(outer_decoder); Http::MockStreamCallbacks callbacks; request_encoder.getStream().addCallbacks(callbacks); @@ -206,15 +206,15 @@ TEST_F(CodecClientTest, IdleTimerClientRemoteCloseWithActiveRequests) { } TEST_F(CodecClientTest, IdleTimerClientLocalCloseWithActiveRequests) { - Http::StreamDecoder* inner_decoder; - NiceMock inner_encoder; + ResponseDecoder* inner_decoder; + NiceMock inner_encoder; EXPECT_CALL(*codec_, newStream(_)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder) -> Http::StreamEncoder& { + .WillOnce(Invoke([&](ResponseDecoder& decoder) -> RequestEncoder& { inner_decoder = &decoder; return inner_encoder; })); - Http::MockStreamDecoder outer_decoder; + Http::MockResponseDecoder outer_decoder; Http::StreamEncoder& request_encoder = client_->newStream(outer_decoder); Http::MockStreamCallbacks callbacks; request_encoder.getStream().addCallbacks(callbacks); @@ -332,9 +332,9 @@ class CodecNetworkTest : public testing::TestWithParam Http::StreamEncoder& { + .WillOnce(Invoke([&](ResponseDecoder& decoder) -> RequestEncoder& { inner_decoder = &decoder; return inner_encoder_; })); @@ -365,8 +365,8 @@ class CodecNetworkTest : public testing::TestWithParam upstream_callbacks_; Network::ClientConnection* client_connection_{}; NiceMock client_callbacks_; - NiceMock inner_encoder_; - NiceMock outer_decoder_; + NiceMock inner_encoder_; + NiceMock outer_decoder_; }; // Send a block of data from upstream, and ensure it is received by the codec. diff --git a/test/common/http/codec_impl_fuzz_test.cc b/test/common/http/codec_impl_fuzz_test.cc index ed592b66dc79..428d253322e2 100644 --- a/test/common/http/codec_impl_fuzz_test.cc +++ b/test/common/http/codec_impl_fuzz_test.cc @@ -87,10 +87,11 @@ class HttpStream : public LinkedObject { enum class StreamState : int { PendingHeaders, PendingDataOrTrailers, Closed }; struct DirectionalState { - // The request encode and response decoder belong to the client, the - // response encoder and request decoder belong to the server. - StreamEncoder* encoder_; - NiceMock decoder_; + // TODO(mattklein123): Split this more clearly into request and response directional state. + RequestEncoder* request_encoder_; + ResponseEncoder* response_encoder_; + NiceMock response_decoder_; + NiceMock request_decoder_; NiceMock stream_callbacks_; StreamState stream_state_; bool local_closed_{false}; @@ -115,7 +116,7 @@ class HttpStream : public LinkedObject { } request_, response_; HttpStream(ClientConnection& client, const TestHeaderMapImpl& request_headers, bool end_stream) { - request_.encoder_ = &client.newStream(response_.decoder_); + request_.request_encoder_ = &client.newStream(response_.response_decoder_); ON_CALL(request_.stream_callbacks_, onResetStream(_, _)) .WillByDefault(InvokeWithoutArgs([this] { ENVOY_LOG_MISC(trace, "reset request for stream index {}", stream_index_); @@ -126,34 +127,32 @@ class HttpStream : public LinkedObject { ENVOY_LOG_MISC(trace, "reset response for stream index {}", stream_index_); resetStream(); })); - ON_CALL(request_.decoder_, decodeHeaders_(_, true)).WillByDefault(InvokeWithoutArgs([this] { - // The HTTP/1 codec needs this to cleanup any latent stream resources. - response_.encoder_->getStream().resetStream(StreamResetReason::LocalReset); - request_.closeRemote(); - })); - ON_CALL(request_.decoder_, decodeData(_, true)).WillByDefault(InvokeWithoutArgs([this] { + ON_CALL(request_.request_decoder_, decodeHeaders_(_, true)) + .WillByDefault(InvokeWithoutArgs([this] { + // The HTTP/1 codec needs this to cleanup any latent stream resources. + response_.response_encoder_->getStream().resetStream(StreamResetReason::LocalReset); + request_.closeRemote(); + })); + ON_CALL(request_.request_decoder_, decodeData(_, true)).WillByDefault(InvokeWithoutArgs([this] { // The HTTP/1 codec needs this to cleanup any latent stream resources. - response_.encoder_->getStream().resetStream(StreamResetReason::LocalReset); + response_.response_encoder_->getStream().resetStream(StreamResetReason::LocalReset); request_.closeRemote(); })); - ON_CALL(request_.decoder_, decodeTrailers_(_)).WillByDefault(InvokeWithoutArgs([this] { + ON_CALL(request_.request_decoder_, decodeTrailers_(_)).WillByDefault(InvokeWithoutArgs([this] { // The HTTP/1 codec needs this to cleanup any latent stream resources. - response_.encoder_->getStream().resetStream(StreamResetReason::LocalReset); + response_.response_encoder_->getStream().resetStream(StreamResetReason::LocalReset); request_.closeRemote(); })); - ON_CALL(response_.decoder_, decodeHeaders_(_, true)).WillByDefault(InvokeWithoutArgs([this] { - response_.closeRemote(); - })); - ON_CALL(response_.decoder_, decodeData(_, true)).WillByDefault(InvokeWithoutArgs([this] { - response_.closeRemote(); - })); - ON_CALL(response_.decoder_, decodeTrailers_(_)).WillByDefault(InvokeWithoutArgs([this] { - response_.closeRemote(); - })); + ON_CALL(response_.response_decoder_, decodeHeaders_(_, true)) + .WillByDefault(InvokeWithoutArgs([this] { response_.closeRemote(); })); + ON_CALL(response_.response_decoder_, decodeData(_, true)) + .WillByDefault(InvokeWithoutArgs([this] { response_.closeRemote(); })); + ON_CALL(response_.response_decoder_, decodeTrailers_(_)) + .WillByDefault(InvokeWithoutArgs([this] { response_.closeRemote(); })); if (!end_stream) { - request_.encoder_->getStream().addCallbacks(request_.stream_callbacks_); + request_.request_encoder_->getStream().addCallbacks(request_.stream_callbacks_); } - request_.encoder_->encodeHeaders(request_headers, end_stream); + request_.request_encoder_->encodeHeaders(request_headers, end_stream); request_.stream_state_ = end_stream ? StreamState::Closed : StreamState::PendingDataOrTrailers; response_.stream_state_ = StreamState::PendingHeaders; } @@ -176,7 +175,7 @@ class HttpStream : public LinkedObject { Http::TestHeaderMapImpl headers = fromSanitizedHeaders(directional_action.continue_headers()); headers.setReferenceKey(Headers::get().Status, "100"); - state.encoder_->encode100ContinueHeaders(headers); + state.response_encoder_->encode100ContinueHeaders(headers); } break; } @@ -186,7 +185,11 @@ class HttpStream : public LinkedObject { if (response && headers.Status() == nullptr) { headers.setReferenceKey(Headers::get().Status, "200"); } - state.encoder_->encodeHeaders(headers, end_stream); + if (response) { + state.response_encoder_->encodeHeaders(headers, end_stream); + } else { + state.request_encoder_->encodeHeaders(headers, end_stream); + } if (end_stream) { state.closeLocal(); } else { @@ -198,7 +201,11 @@ class HttpStream : public LinkedObject { case test::common::http::DirectionalAction::kData: { if (state.isLocalOpen() && state.stream_state_ == StreamState::PendingDataOrTrailers) { Buffer::OwnedImpl buf(std::string(directional_action.data() % (1024 * 1024), 'a')); - state.encoder_->encodeData(buf, end_stream); + if (response) { + state.response_encoder_->encodeData(buf, end_stream); + } else { + state.request_encoder_->encodeData(buf, end_stream); + } if (end_stream) { state.closeLocal(); } @@ -208,7 +215,11 @@ class HttpStream : public LinkedObject { case test::common::http::DirectionalAction::kDataValue: { if (state.isLocalOpen() && state.stream_state_ == StreamState::PendingDataOrTrailers) { Buffer::OwnedImpl buf(directional_action.data_value()); - state.encoder_->encodeData(buf, end_stream); + if (response) { + state.response_encoder_->encodeData(buf, end_stream); + } else { + state.request_encoder_->encodeData(buf, end_stream); + } if (end_stream) { state.closeLocal(); } @@ -217,7 +228,13 @@ class HttpStream : public LinkedObject { } case test::common::http::DirectionalAction::kTrailers: { if (state.isLocalOpen() && state.stream_state_ == StreamState::PendingDataOrTrailers) { - state.encoder_->encodeTrailers(fromSanitizedHeaders(directional_action.trailers())); + if (response) { + state.response_encoder_->encodeTrailers( + fromSanitizedHeaders(directional_action.trailers())); + } else { + state.request_encoder_->encodeTrailers( + fromSanitizedHeaders(directional_action.trailers())); + } state.stream_state_ = StreamState::Closed; state.closeLocal(); } @@ -225,7 +242,13 @@ class HttpStream : public LinkedObject { } case test::common::http::DirectionalAction::kResetStream: { if (state.stream_state_ != StreamState::Closed) { - state.encoder_->getStream().resetStream( + StreamEncoder* encoder; + if (response) { + encoder = state.response_encoder_; + } else { + encoder = state.request_encoder_; + } + encoder->getStream().resetStream( static_cast(directional_action.reset_stream())); request_.stream_state_ = response_.stream_state_ = StreamState::Closed; } @@ -242,7 +265,13 @@ class HttpStream : public LinkedObject { } else { --state.read_disable_count_; } - state.encoder_->getStream().readDisable(disable); + StreamEncoder* encoder; + if (response) { + encoder = state.response_encoder_; + } else { + encoder = state.request_encoder_; + } + encoder->getStream().readDisable(disable); } break; } @@ -401,20 +430,20 @@ void codecFuzz(const test::common::http::CodecImplFuzzTestCase& input, HttpVersi std::list pending_streams; std::list streams; // For new streams when we aren't expecting one (e.g. as a result of a mutation). - NiceMock orphan_request_decoder; + NiceMock orphan_request_decoder; ON_CALL(server_callbacks, newStream(_, _)) - .WillByDefault(Invoke([&](StreamEncoder& encoder, bool) -> StreamDecoder& { + .WillByDefault(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { if (pending_streams.empty()) { return orphan_request_decoder; } auto stream_ptr = pending_streams.front()->removeFromList(pending_streams); HttpStream* const stream = stream_ptr.get(); stream_ptr->moveIntoListBack(std::move(stream_ptr), streams); - stream->response_.encoder_ = &encoder; + stream->response_.response_encoder_ = &encoder; encoder.getStream().addCallbacks(stream->response_.stream_callbacks_); stream->stream_index_ = streams.size() - 1; - return stream->request_.decoder_; + return stream->request_.request_decoder_; })); const auto client_server_buf_drain = [&client_write_buf, &server_write_buf] { diff --git a/test/common/http/codec_wrappers_test.cc b/test/common/http/codec_wrappers_test.cc index d660c4f85f20..6f690cdbb593 100644 --- a/test/common/http/codec_wrappers_test.cc +++ b/test/common/http/codec_wrappers_test.cc @@ -8,33 +8,34 @@ using testing::_; namespace Envoy { namespace Http { -class MockStreamEncoderWrapper : public StreamEncoderWrapper { +class MockRequestEncoderWrapper : public RequestEncoderWrapper { public: - MockStreamEncoderWrapper() : StreamEncoderWrapper(inner_encoder_) {} + MockRequestEncoderWrapper() : RequestEncoderWrapper(inner_encoder_) {} void onEncodeComplete() override { encode_complete_ = true; } - MockStreamEncoder& innerEncoder() { return inner_encoder_; } + MockRequestEncoder& innerEncoder() { return inner_encoder_; } bool encodeComplete() const { return encode_complete_; } private: - MockStreamEncoder inner_encoder_; + MockRequestEncoder inner_encoder_; bool encode_complete_{}; }; -TEST(StreamEncoderWrapper, HeaderOnlyEncode) { - MockStreamEncoderWrapper wrapper; +TEST(RequestEncoderWrapper, HeaderOnlyEncode) { + MockRequestEncoderWrapper wrapper; EXPECT_CALL(wrapper.innerEncoder(), encodeHeaders(_, true)); - wrapper.encodeHeaders(TestHeaderMapImpl{{":status", "200"}}, true); + wrapper.encodeHeaders( + TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}, {":authority", "foo"}}, true); EXPECT_TRUE(wrapper.encodeComplete()); } -TEST(StreamEncoderWrapper, HeaderAndBodyEncode) { - MockStreamEncoderWrapper wrapper; +TEST(RequestEncoderWrapper, HeaderAndBodyEncode) { + MockRequestEncoderWrapper wrapper; - TestHeaderMapImpl response_headers{{":status", "200"}}; EXPECT_CALL(wrapper.innerEncoder(), encodeHeaders(_, false)); - wrapper.encodeHeaders(response_headers, false); + wrapper.encodeHeaders( + TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}, {":authority", "foo"}}, false); EXPECT_FALSE(wrapper.encodeComplete()); Buffer::OwnedImpl data; @@ -43,12 +44,12 @@ TEST(StreamEncoderWrapper, HeaderAndBodyEncode) { EXPECT_TRUE(wrapper.encodeComplete()); } -TEST(StreamEncoderWrapper, HeaderAndBodyAndTrailersEncode) { - MockStreamEncoderWrapper wrapper; +TEST(RequestEncoderWrapper, HeaderAndBodyAndTrailersEncode) { + MockRequestEncoderWrapper wrapper; - TestHeaderMapImpl response_headers{{":status", "200"}}; EXPECT_CALL(wrapper.innerEncoder(), encodeHeaders(_, false)); - wrapper.encodeHeaders(response_headers, false); + wrapper.encodeHeaders( + TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}, {":authority", "foo"}}, false); EXPECT_FALSE(wrapper.encodeComplete()); Buffer::OwnedImpl data; @@ -61,17 +62,5 @@ TEST(StreamEncoderWrapper, HeaderAndBodyAndTrailersEncode) { EXPECT_TRUE(wrapper.encodeComplete()); } -TEST(StreamEncoderWrapper, 100ContinueHeaderEncode) { - MockStreamEncoderWrapper wrapper; - - EXPECT_CALL(wrapper.innerEncoder(), encode100ContinueHeaders(_)); - wrapper.encode100ContinueHeaders(TestHeaderMapImpl{{":status", "100"}}); - EXPECT_FALSE(wrapper.encodeComplete()); - - EXPECT_CALL(wrapper.innerEncoder(), encodeHeaders(_, true)); - wrapper.encodeHeaders(TestHeaderMapImpl{{":status", "200"}}, true); - EXPECT_TRUE(wrapper.encodeComplete()); -} - } // namespace Http } // namespace Envoy diff --git a/test/common/http/common.h b/test/common/http/common.h index d9b4f7823a20..ece286f1075b 100644 --- a/test/common/http/common.h +++ b/test/common/http/common.h @@ -38,7 +38,7 @@ class CodecClientForTest : public Http::CodecClient { * Mock callbacks used for conn pool testing. */ struct ConnPoolCallbacks : public Http::ConnectionPool::Callbacks { - void onPoolReady(Http::StreamEncoder& encoder, Upstream::HostDescriptionConstSharedPtr host, + void onPoolReady(Http::RequestEncoder& encoder, Upstream::HostDescriptionConstSharedPtr host, const StreamInfo::StreamInfo&) override { outer_encoder_ = &encoder; host_ = host; @@ -53,7 +53,7 @@ struct ConnPoolCallbacks : public Http::ConnectionPool::Callbacks { ReadyWatcher pool_failure_; ReadyWatcher pool_ready_; - Http::StreamEncoder* outer_encoder_{}; + Http::RequestEncoder* outer_encoder_{}; Upstream::HostDescriptionConstSharedPtr host_; }; diff --git a/test/common/http/conn_manager_impl_fuzz_test.cc b/test/common/http/conn_manager_impl_fuzz_test.cc index 0318637f2016..72a490308a38 100644 --- a/test/common/http/conn_manager_impl_fuzz_test.cc +++ b/test/common/http/conn_manager_impl_fuzz_test.cc @@ -409,8 +409,8 @@ class FuzzStream { ConnectionManagerImpl& conn_manager_; FuzzConfig& config_; - StreamDecoder* decoder_{}; - NiceMock encoder_; + RequestDecoder* decoder_{}; + NiceMock encoder_; MockStreamDecoderFilter* decoder_filter_{}; MockStreamEncoderFilter* encoder_filter_{}; StreamState request_state_; diff --git a/test/common/http/conn_manager_impl_test.cc b/test/common/http/conn_manager_impl_test.cc index 724779c73be2..d22c3c058180 100644 --- a/test/common/http/conn_manager_impl_test.cc +++ b/test/common/http/conn_manager_impl_test.cc @@ -204,7 +204,7 @@ class HttpConnectionManagerImplTest : public testing::Test, public ConnectionMan setUpBufferLimits(); EXPECT_CALL(*codec_, dispatch(_)) .WillOnce(Invoke([&, request_with_data_and_trailers](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; if (request_with_data_and_trailers) { @@ -401,7 +401,7 @@ class HttpConnectionManagerImplTest : public testing::Test, public ConnectionMan NiceMock conn_pool_; // for websocket tests // TODO(mattklein123): Not all tests have been converted over to better setup. Convert the rest. - MockStreamEncoder response_encoder_; + MockResponseEncoder response_encoder_; std::vector decoder_filters_; std::vector encoder_filters_; }; @@ -436,8 +436,8 @@ TEST_F(HttpConnectionManagerImplTest, HeaderOnlyRequestAndResponse) { // When dispatch is called on the codec, we pretend to get a new stream and then fire a headers // only request into it. Then we respond into the filter. - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)) .Times(2) .WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { @@ -496,8 +496,8 @@ TEST_F(HttpConnectionManagerImplTest, 100ContinueResponse) { // When dispatch is called on the codec, we pretend to get a new stream and then fire a headers // only request into it. Then we respond into the filter. - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(encoder); @@ -667,7 +667,7 @@ TEST_F(HttpConnectionManagerImplTest, InvalidPathWithDualFilter) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{new TestHeaderMapImpl{ {":authority", "host"}, {":path", "http://api.lyft.com/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), true); @@ -704,7 +704,7 @@ TEST_F(HttpConnectionManagerImplTest, PathFailedtoSanitize) { normalize_path_ = true; EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/ab%00c"}, // "%00" is not valid in path according to RFC @@ -760,7 +760,7 @@ TEST_F(HttpConnectionManagerImplTest, FilterShouldUseSantizedPath) { EXPECT_CALL(*filter, setDecoderFilterCallbacks(_)); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{new TestHeaderMapImpl{ {":authority", "host"}, {":path", original_path}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), true); @@ -781,7 +781,7 @@ TEST_F(HttpConnectionManagerImplTest, RouteShouldUseSantizedPath) { const std::string normalized_path = "/z"; EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{new TestHeaderMapImpl{ {":authority", "host"}, {":path", original_path}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), true); @@ -934,8 +934,8 @@ TEST_F(HttpConnectionManagerImplTest, StartAndFinishSpanNormalFlow) { use_remote_address_ = false; EXPECT_CALL(random_, uuid()).Times(0); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(encoder); @@ -1001,8 +1001,8 @@ TEST_F(HttpConnectionManagerImplTest, StartAndFinishSpanNormalFlowIngressDecorat use_remote_address_ = false; EXPECT_CALL(random_, uuid()).Times(0); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(encoder); @@ -1065,8 +1065,8 @@ TEST_F(HttpConnectionManagerImplTest, StartAndFinishSpanNormalFlowIngressDecorat use_remote_address_ = false; EXPECT_CALL(random_, uuid()).Times(0); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(encoder); @@ -1145,8 +1145,8 @@ TEST_F(HttpConnectionManagerImplTest, StartAndFinishSpanNormalFlowEgressDecorato use_remote_address_ = false; EXPECT_CALL(random_, uuid()).Times(0); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(encoder); @@ -1226,8 +1226,8 @@ TEST_F(HttpConnectionManagerImplTest, StartAndFinishSpanNormalFlowEgressDecorato use_remote_address_ = false; EXPECT_CALL(random_, uuid()).Times(0); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(encoder); @@ -1282,8 +1282,8 @@ TEST_F(HttpConnectionManagerImplTest, use_remote_address_ = false; EXPECT_CALL(random_, uuid()).Times(0); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(encoder); @@ -1338,8 +1338,8 @@ TEST_F(HttpConnectionManagerImplTest, TestAccessLog) { local_address); })); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(encoder); @@ -1382,8 +1382,8 @@ TEST_F(HttpConnectionManagerImplTest, TestDownstreamDisconnectAccessLog) { stream_info.hasResponseFlag(StreamInfo::ResponseFlag::DownstreamConnectionTermination)); })); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(encoder); @@ -1421,8 +1421,8 @@ TEST_F(HttpConnectionManagerImplTest, TestAccessLogWithTrailers) { EXPECT_NE(nullptr, stream_info.routeEntry()); })); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(encoder); @@ -1470,8 +1470,8 @@ TEST_F(HttpConnectionManagerImplTest, TestAccessLogWithInvalidRequest) { EXPECT_EQ(nullptr, stream_info.routeEntry()); })); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(encoder); @@ -1509,8 +1509,8 @@ TEST_F(HttpConnectionManagerImplTest, TestAccessLogSsl) { EXPECT_NE(nullptr, stream_info.routeEntry()); })); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(encoder); @@ -1552,8 +1552,8 @@ TEST_F(HttpConnectionManagerImplTest, DoNotStartSpanIfTracingIsNotEnabled) { callbacks.addStreamDecoderFilter(filter); })); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(encoder); @@ -1577,8 +1577,8 @@ TEST_F(HttpConnectionManagerImplTest, DoNotStartSpanIfTracingIsNotEnabled) { TEST_F(HttpConnectionManagerImplTest, NoPath) { setup(false, ""); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(encoder); HeaderMapPtr headers{new TestHeaderMapImpl{{":authority", "host"}, {":method", "NOT_CONNECT"}}}; @@ -1603,7 +1603,7 @@ TEST_F(HttpConnectionManagerImplTest, PerStreamIdleTimeoutNotConfigured) { EXPECT_CALL(filter_callbacks_.connection_.dispatcher_, createTimer_(_)).Times(0); EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; @@ -1702,7 +1702,7 @@ TEST_F(HttpConnectionManagerImplTest, TestStreamIdleAccessLog) { stream_idle_timeout_ = std::chrono::milliseconds(10); setup(false, ""); - NiceMock encoder; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance&) -> void { Event::MockTimer* idle_timer = setUpTimer(); EXPECT_CALL(*idle_timer, enableTimer(std::chrono::milliseconds(10), _)); @@ -1758,7 +1758,7 @@ TEST_F(HttpConnectionManagerImplTest, PerStreamIdleTimeoutRouteOverride) { EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { Event::MockTimer* idle_timer = setUpTimer(); EXPECT_CALL(*idle_timer, enableTimer(std::chrono::milliseconds(10), _)); - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; @@ -1784,7 +1784,7 @@ TEST_F(HttpConnectionManagerImplTest, PerStreamIdleTimeoutRouteZeroOverride) { EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { Event::MockTimer* idle_timer = setUpTimer(); EXPECT_CALL(*idle_timer, enableTimer(std::chrono::milliseconds(10), _)); - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; @@ -1808,7 +1808,7 @@ TEST_F(HttpConnectionManagerImplTest, PerStreamIdleTimeoutAfterDownstreamHeaders // Codec sends downstream request headers. EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); Event::MockTimer* idle_timer = setUpTimer(); HeaderMapPtr headers{ @@ -1849,7 +1849,7 @@ TEST_F(HttpConnectionManagerImplTest, PerStreamIdleTimeoutNormalTermination) { // Codec sends downstream request headers. Event::MockTimer* idle_timer = setUpTimer(); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; @@ -1877,7 +1877,7 @@ TEST_F(HttpConnectionManagerImplTest, PerStreamIdleTimeoutAfterDownstreamHeaders // Codec sends downstream request headers. EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); Event::MockTimer* idle_timer = setUpTimer(); HeaderMapPtr headers{ @@ -1930,7 +1930,7 @@ TEST_F(HttpConnectionManagerImplTest, PerStreamIdleTimeoutAfterUpstreamHeaders) // Codec sends downstream request headers, upstream response headers are // encoded. EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); Event::MockTimer* idle_timer = setUpTimer(); HeaderMapPtr headers{ @@ -1979,7 +1979,7 @@ TEST_F(HttpConnectionManagerImplTest, PerStreamIdleTimeoutAfterBidiData) { // Codec sends downstream request headers, upstream response headers are // encoded, data events happen in various directions. Event::MockTimer* idle_timer = setUpTimer(); - StreamDecoder* decoder; + RequestDecoder* decoder; EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ @@ -2108,7 +2108,7 @@ TEST_F(HttpConnectionManagerImplTest, RequestTimeoutIsNotDisarmedOnIncompleteReq EXPECT_CALL(*request_timer, enableTimer(request_timeout_, _)).Times(1); EXPECT_CALL(*request_timer, disableTimer()).Times(0); - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; @@ -2130,7 +2130,7 @@ TEST_F(HttpConnectionManagerImplTest, RequestTimeoutIsDisarmedOnCompleteRequestW Event::MockTimer* request_timer = setUpTimer(); EXPECT_CALL(*request_timer, enableTimer(request_timeout_, _)).Times(1); - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; @@ -2152,7 +2152,7 @@ TEST_F(HttpConnectionManagerImplTest, RequestTimeoutIsDisarmedOnCompleteRequestW Event::MockTimer* request_timer = setUpTimer(); EXPECT_CALL(*request_timer, enableTimer(request_timeout_, _)).Times(1); - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "POST"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -2174,7 +2174,7 @@ TEST_F(HttpConnectionManagerImplTest, RequestTimeoutIsDisarmedOnCompleteRequestW EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { Event::MockTimer* request_timer = setUpTimer(); EXPECT_CALL(*request_timer, enableTimer(request_timeout_, _)).Times(1); - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; @@ -2206,7 +2206,7 @@ TEST_F(HttpConnectionManagerImplTest, RequestTimeoutIsDisarmedOnEncodeHeaders) { Event::MockTimer* request_timer = setUpTimer(); EXPECT_CALL(*request_timer, enableTimer(request_timeout_, _)).Times(1); - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; @@ -2229,7 +2229,7 @@ TEST_F(HttpConnectionManagerImplTest, RequestTimeoutIsDisarmedOnConnectionTermin Event::MockTimer* request_timer = setUpTimer(); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; @@ -2249,8 +2249,8 @@ TEST_F(HttpConnectionManagerImplTest, RequestTimeoutIsDisarmedOnConnectionTermin TEST_F(HttpConnectionManagerImplTest, RejectWebSocketOnNonWebSocketRoute) { setup(false, ""); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(encoder); HeaderMapPtr headers{new TestHeaderMapImpl{{":authority", "host"}, @@ -2290,7 +2290,7 @@ TEST_F(HttpConnectionManagerImplTest, FooUpgradeDrainClose) { .WillRepeatedly(Invoke( [&](HeaderMap&, bool) -> FilterHeadersStatus { return FilterHeadersStatus::Continue; })); - NiceMock encoder; + NiceMock encoder; EXPECT_CALL(encoder, encodeHeaders(_, false)) .WillOnce(Invoke([&](const HeaderMap& headers, bool) -> void { EXPECT_NE(nullptr, headers.Connection()); @@ -2309,7 +2309,7 @@ TEST_F(HttpConnectionManagerImplTest, FooUpgradeDrainClose) { // When dispatch is called on the codec, we pretend to get a new stream and then fire a headers // only request into it. Then we respond into the filter. - StreamDecoder* decoder = nullptr; + RequestDecoder* decoder = nullptr; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(encoder); @@ -2348,8 +2348,8 @@ TEST_F(HttpConnectionManagerImplTest, DrainClose) { return FilterHeadersStatus::StopIteration; })); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { decoder = &conn_manager_->newStream(encoder); HeaderMapPtr headers{ @@ -2386,7 +2386,7 @@ TEST_F(HttpConnectionManagerImplTest, ResponseBeforeRequestComplete) { setup(false, "envoy-server-test"); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -2418,7 +2418,7 @@ TEST_F(HttpConnectionManagerImplTest, DisconnectOnProxyConnectionDisconnect) { setup(false, "envoy-server-test"); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{new TestHeaderMapImpl{ {":authority", "host"}, {":path", "/"}, {":method", "GET"}, {"proxy-connection", "close"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -2461,8 +2461,8 @@ TEST_F(HttpConnectionManagerImplTest, ResponseStartBeforeRequestComplete) { .WillOnce(Return(FilterHeadersStatus::StopIteration)); // Start the request - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { decoder = &conn_manager_->newStream(encoder); HeaderMapPtr headers{ @@ -2503,7 +2503,7 @@ TEST_F(HttpConnectionManagerImplTest, DownstreamDisconnect) { InSequence s; setup(false, ""); - NiceMock encoder; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { conn_manager_->newStream(encoder); data.drain(2); @@ -2555,8 +2555,8 @@ TEST_F(HttpConnectionManagerImplTest, TestDownstreamProtocolErrorAccessLog) { EXPECT_TRUE(stream_info.hasResponseFlag(StreamInfo::ResponseFlag::DownstreamProtocolError)); })); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance&) -> void { decoder = &conn_manager_->newStream(encoder); throw CodecProtocolException("protocol error"); @@ -2586,8 +2586,8 @@ TEST_F(HttpConnectionManagerImplTest, TestDownstreamProtocolErrorAfterHeadersAcc EXPECT_TRUE(stream_info.hasResponseFlag(StreamInfo::ResponseFlag::DownstreamProtocolError)); })); - StreamDecoder* decoder = nullptr; - NiceMock encoder; + RequestDecoder* decoder = nullptr; + NiceMock encoder; EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance&) -> void { decoder = &conn_manager_->newStream(encoder); @@ -2683,8 +2683,8 @@ TEST_F(HttpConnectionManagerImplTest, IdleTimeout) { callbacks.addStreamDecoderFilter(StreamDecoderFilterSharedPtr{filter}); })); - NiceMock encoder; - StreamDecoder* decoder = nullptr; + NiceMock encoder; + RequestDecoder* decoder = nullptr; EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { decoder = &conn_manager_->newStream(encoder); HeaderMapPtr headers{ @@ -2752,8 +2752,8 @@ TEST_F(HttpConnectionManagerImplTest, ConnectionDuration) { callbacks.addStreamDecoderFilter(StreamDecoderFilterSharedPtr{filter}); })); - NiceMock encoder; - StreamDecoder* decoder = nullptr; + NiceMock encoder; + RequestDecoder* decoder = nullptr; EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { decoder = &conn_manager_->newStream(encoder); HeaderMapPtr headers{ @@ -2795,7 +2795,7 @@ TEST_F(HttpConnectionManagerImplTest, IntermediateBufferingEarlyResponse) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -2841,7 +2841,7 @@ TEST_F(HttpConnectionManagerImplTest, DoubleBuffering) { Buffer::OwnedImpl fake_data("hello"); Buffer::OwnedImpl fake_data_copy("hello"); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -2882,7 +2882,7 @@ TEST_F(HttpConnectionManagerImplTest, ZeroByteDataFiltering) { InSequence s; setup(false, ""); - StreamDecoder* decoder = nullptr; + RequestDecoder* decoder = nullptr; EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ @@ -2923,7 +2923,7 @@ TEST_F(HttpConnectionManagerImplTest, FilterAddTrailersInTrailersCallback) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -3009,7 +3009,7 @@ TEST_F(HttpConnectionManagerImplTest, FilterAddTrailersInDataCallbackNoTrailers) setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -3100,7 +3100,7 @@ TEST_F(HttpConnectionManagerImplTest, FilterAddBodyInTrailersCallback) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -3181,7 +3181,7 @@ TEST_F(HttpConnectionManagerImplTest, FilterAddBodyInTrailersCallback_NoDataFram setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -3240,7 +3240,7 @@ TEST_F(HttpConnectionManagerImplTest, FilterAddBodyInTrailersCallback_ContinueAf setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -3305,7 +3305,7 @@ TEST_F(HttpConnectionManagerImplTest, FilterAddBodyDuringDecodeData) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -3373,7 +3373,7 @@ TEST_F(HttpConnectionManagerImplTest, FilterAddBodyInline) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), true); @@ -3423,7 +3423,7 @@ TEST_F(HttpConnectionManagerImplTest, FilterClearRouteCache) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), true); @@ -3545,7 +3545,7 @@ TEST_F(HttpConnectionManagerImplTest, UnderlyingConnectionWatermarksPassedOnWith // Create the stream. Defer the creation of the filter chain by not sending // complete headers. - StreamDecoder* decoder; + RequestDecoder* decoder; { setUpBufferLimits(); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { @@ -3605,7 +3605,7 @@ TEST_F(HttpConnectionManagerImplTest, UnderlyingConnectionWatermarksUnwoundWithL // Create the stream. Defer the creation of the filter chain by not sending // complete headers. - StreamDecoder* decoder; + RequestDecoder* decoder; { setUpBufferLimits(); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { @@ -3756,7 +3756,7 @@ TEST_F(HttpConnectionManagerImplTest, HitRequestBufferLimitsIntermediateFilter) setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -3860,7 +3860,7 @@ TEST_F(HttpConnectionManagerImplTest, FilterHeadReply) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "HEAD"}}}; decoder->decodeHeaders(std::move(headers), true); @@ -3898,7 +3898,7 @@ TEST_F(HttpConnectionManagerImplTest, ResetWithStoppedFilter) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), true); @@ -3942,7 +3942,7 @@ TEST_F(HttpConnectionManagerImplTest, FilterContinueAndEndStreamHeaders) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); auto headers = std::make_unique( std::initializer_list>( {{":authority", "host"}, {":path", "/"}, {":method", "GET"}})); @@ -3982,7 +3982,7 @@ TEST_F(HttpConnectionManagerImplTest, FilterContinueAndEndStreamData) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); auto headers = makeHeaderMap({{":authority", "host"}, {":path", "/"}, {":method", "GET"}}); decoder->decodeHeaders(std::move(headers), false); @@ -4022,7 +4022,7 @@ TEST_F(HttpConnectionManagerImplTest, FilterContinueAndEndStreamTrailers) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); auto headers = makeHeaderMap({{":authority", "host"}, {":path", "/"}, {":method", "GET"}}); decoder->decodeHeaders(std::move(headers), false); @@ -4068,7 +4068,7 @@ TEST_F(HttpConnectionManagerImplTest, FilterAddBodyContinuation) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), true); @@ -4153,7 +4153,7 @@ TEST_F(HttpConnectionManagerImplTest, AddDataWithAllContinue) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), true); @@ -4255,7 +4255,7 @@ TEST_F(HttpConnectionManagerImplTest, AddDataWithStopAndContinue) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), true); @@ -4330,7 +4330,7 @@ TEST_F(HttpConnectionManagerImplTest, FilterDirectDecodeEncodeDataNoTrailers) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -4409,7 +4409,7 @@ TEST_F(HttpConnectionManagerImplTest, FilterDirectDecodeEncodeDataTrailers) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -4503,7 +4503,7 @@ TEST_F(HttpConnectionManagerImplTest, MultipleFilters) { setup(false, ""); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -4614,7 +4614,7 @@ TEST_F(HttpConnectionManagerImplTest, NoNewStreamWhenOverloaded) { Server::OverloadActionState::Active); EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -4648,7 +4648,7 @@ TEST_F(HttpConnectionManagerImplTest, DisableKeepAliveWhenOverloaded) { })); EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{new TestHeaderMapImpl{ {":authority", "host"}, {":path", "/"}, {":method", "GET"}, {"connection", "keep-alive"}}}; decoder->decodeHeaders(std::move(headers), true); @@ -4767,7 +4767,7 @@ TEST_F(HttpConnectionManagerImplTest, DisableKeepAliveWhenDraining) { })); EXPECT_CALL(*codec_, dispatch(_)).WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{new TestHeaderMapImpl{ {":authority", "host"}, {":path", "/"}, {":method", "GET"}, {"connection", "keep-alive"}}}; decoder->decodeHeaders(std::move(headers), true); @@ -4800,7 +4800,7 @@ TEST_F(HttpConnectionManagerImplTest, TestSessionTrace) { setupFilterChain(1, 1); // Create a new stream - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); // Send headers to that stream, and verify we both set and clear the tracked object. { @@ -4859,7 +4859,7 @@ TEST_F(HttpConnectionManagerImplTest, TestSrdsRouteNotFound) { .Times(2) .WillRepeatedly(Return(nullptr)); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":method", "GET"}, {":path", "/foo"}}}; decoder->decodeHeaders(std::move(headers), true); @@ -4889,7 +4889,7 @@ TEST_F(HttpConnectionManagerImplTest, TestSrdsUpdate) { .WillOnce(Return(nullptr)) // refreshCachedRoute first time. .WillOnce(Return(route_config_)); // triggered by callbacks_->route(), SRDS now updated. EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":method", "GET"}, {":path", "/foo"}}}; decoder->decodeHeaders(std::move(headers), true); @@ -4952,7 +4952,7 @@ TEST_F(HttpConnectionManagerImplTest, TestSrdsCrossScopeReroute) { return route_config2; })); EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{new TestHeaderMapImpl{ {":authority", "host"}, {":method", "GET"}, {"scope_key", "foo"}, {":path", "/foo"}}}; decoder->decodeHeaders(std::move(headers), false); @@ -5003,7 +5003,7 @@ TEST_F(HttpConnectionManagerImplTest, TestSrdsRouteFound) { scopedRouteConfigProvider()->config()->route_config_.get()), route(_, _, _)) .WillOnce(Return(route1)); - StreamDecoder* decoder = nullptr; + RequestDecoder* decoder = nullptr; EXPECT_CALL(*codec_, dispatch(_)).WillOnce(Invoke([&](Buffer::Instance& data) -> void { decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ @@ -5070,8 +5070,8 @@ TEST_F(HttpConnectionManagerImplTest, HeaderOnlyRequestAndResponseUsingHttp3) { // Pretend to get a new stream and then fire a headers only request into it. Then we respond into // the filter. - NiceMock encoder; - StreamDecoder& decoder = conn_manager_->newStream(encoder); + NiceMock encoder; + RequestDecoder& decoder = conn_manager_->newStream(encoder); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder.decodeHeaders(std::move(headers), true); @@ -5108,7 +5108,7 @@ TEST_F(HttpConnectionManagerImplTest, ConnectionFilterState) { setupFilterChain(1, 0, /* num_requests = */ 3); EXPECT_CALL(*codec_, dispatch(_)).Times(2).WillRepeatedly(Invoke([&](Buffer::Instance&) -> void { - StreamDecoder* decoder = &conn_manager_->newStream(response_encoder_); + RequestDecoder* decoder = &conn_manager_->newStream(response_encoder_); HeaderMapPtr headers{ new TestHeaderMapImpl{{":authority", "host"}, {":path", "/"}, {":method", "GET"}}}; decoder->decodeHeaders(std::move(headers), true); diff --git a/test/common/http/http1/codec_impl_test.cc b/test/common/http/http1/codec_impl_test.cc index d1ad84afb984..9f0fdde50e70 100644 --- a/test/common/http/http1/codec_impl_test.cc +++ b/test/common/http/http1/codec_impl_test.cc @@ -71,15 +71,14 @@ class Http1ServerConnectionImplTest : public testing::Test { // Then send a response just to clean up. void sendAndValidateRequestAndSendResponse(absl::string_view raw_request, const TestHeaderMapImpl& expected_request_headers) { - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .Times(1) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); - EXPECT_CALL(decoder, decodeHeaders_(HeaderMapEqual(&expected_request_headers), true)).Times(1); + EXPECT_CALL(decoder, decodeHeaders_(HeaderMapEqual(&expected_request_headers), true)); Buffer::OwnedImpl buffer(raw_request); codec_->dispatch(buffer); EXPECT_EQ(0U, buffer.length()); @@ -107,10 +106,10 @@ void Http1ServerConnectionImplTest::expect400(Protocol p, bool allow_absolute_ur max_request_headers_kb_, max_request_headers_count_); } - Http::MockStreamDecoder decoder; - Http::StreamEncoder* response_encoder = nullptr; + MockRequestDecoder decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -136,7 +135,7 @@ void Http1ServerConnectionImplTest::expectHeadersTest(Protocol p, bool allow_abs max_request_headers_kb_, max_request_headers_count_); } - Http::MockStreamDecoder decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); EXPECT_CALL(decoder, decodeHeaders_(HeaderMapEqual(&expected_headers), true)).Times(1); @@ -156,16 +155,15 @@ void Http1ServerConnectionImplTest::expectTrailersTest(bool enable_trailers) { max_request_headers_kb_, max_request_headers_count_); } - StrictMock decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce( - Invoke([&](Http::StreamEncoder&, bool) -> Http::StreamDecoder& { return decoder; })); + .WillOnce(Invoke([&](ResponseEncoder&, bool) -> RequestDecoder& { return decoder; })); EXPECT_CALL(decoder, decodeHeaders_(_, false)); if (enable_trailers) { EXPECT_CALL(decoder, decodeData(_, false)).Times(AtLeast(1)); - EXPECT_CALL(decoder, decodeTrailers_).Times(1); + EXPECT_CALL(decoder, decodeTrailers_); } else { EXPECT_CALL(decoder, decodeData(_, false)).Times(AtLeast(1)); EXPECT_CALL(decoder, decodeData(_, true)); @@ -186,10 +184,9 @@ void Http1ServerConnectionImplTest::testTrailersExceedLimit(std::string trailer_ std::make_unique(connection_, store_, callbacks_, codec_settings_, max_request_headers_kb_, max_request_headers_count_); std::string exception_reason; - NiceMock decoder; + NiceMock decoder; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce( - Invoke([&](Http::StreamEncoder&, bool) -> Http::StreamDecoder& { return decoder; })); + .WillOnce(Invoke([&](ResponseEncoder&, bool) -> RequestDecoder& { return decoder; })); if (enable_trailers) { EXPECT_CALL(decoder, decodeHeaders_(_, false)); @@ -220,10 +217,10 @@ void Http1ServerConnectionImplTest::testRequestHeadersExceedLimit(std::string he initialize(); std::string exception_reason; - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -240,10 +237,10 @@ void Http1ServerConnectionImplTest::testRequestHeadersExceedLimit(std::string he void Http1ServerConnectionImplTest::testRequestHeadersAccepted(std::string header_string) { initialize(); - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -259,7 +256,7 @@ TEST_F(Http1ServerConnectionImplTest, EmptyHeader) { InSequence sequence; - Http::MockStreamDecoder decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); TestHeaderMapImpl expected_headers{ @@ -280,7 +277,7 @@ TEST_F(Http1ServerConnectionImplTest, IdentityEncoding) { InSequence sequence; - Http::MockStreamDecoder decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); TestHeaderMapImpl expected_headers{ @@ -299,7 +296,7 @@ TEST_F(Http1ServerConnectionImplTest, ChunkedBody) { InSequence sequence; - Http::MockStreamDecoder decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); TestHeaderMapImpl expected_headers{ @@ -324,7 +321,7 @@ TEST_F(Http1ServerConnectionImplTest, IdentityAndChunkedBody) { InSequence sequence; - Http::MockStreamDecoder decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); Buffer::OwnedImpl buffer("POST / HTTP/1.1\r\ntransfer-encoding: " @@ -355,7 +352,7 @@ TEST_F(Http1ServerConnectionImplTest, Http10) { InSequence sequence; - Http::MockStreamDecoder decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); TestHeaderMapImpl expected_headers{{":path", "/"}, {":method", "GET"}}; @@ -387,14 +384,14 @@ TEST_F(Http1ServerConnectionImplTest, Http10Absolute) { TEST_F(Http1ServerConnectionImplTest, Http10MultipleResponses) { initialize(); - Http::MockStreamDecoder decoder; + MockRequestDecoder decoder; // Send a full HTTP/1.0 request and proxy a response. { Buffer::OwnedImpl buffer( "GET /foobar HTTP/1.0\r\nHost: www.somewhere.com\r\nconnection: keep-alive\r\n\r\n"); - Http::StreamEncoder* response_encoder = nullptr; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -416,9 +413,9 @@ TEST_F(Http1ServerConnectionImplTest, Http10MultipleResponses) { {":authority", "www.somewhere.com"}, {":path", "/foobar"}, {":method", "GET"}}; Buffer::OwnedImpl buffer("GET /foobar HTTP/1.1\r\nHost: www.somewhere.com\r\n\r\n"); - Http::StreamEncoder* response_encoder = nullptr; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -479,10 +476,9 @@ TEST_F(Http1ServerConnectionImplTest, Http11InvalidTrailerPost) { std::string output; ON_CALL(connection_, write(_, _)).WillByDefault(AddBufferToString(&output)); - StrictMock decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce( - Invoke([&](Http::StreamEncoder&, bool) -> Http::StreamDecoder& { return decoder; })); + .WillOnce(Invoke([&](ResponseEncoder&, bool) -> RequestDecoder& { return decoder; })); EXPECT_CALL(decoder, decodeHeaders_(_, false)); EXPECT_CALL(decoder, decodeData(_, false)).Times(AtLeast(1)); @@ -551,7 +547,7 @@ TEST_F(Http1ServerConnectionImplTest, SimpleGet) { InSequence sequence; - Http::MockStreamDecoder decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); TestHeaderMapImpl expected_headers{{":path", "/"}, {":method", "GET"}}; @@ -578,7 +574,7 @@ TEST_F(Http1ServerConnectionImplTest, BadRequestNoStream) { TEST_F(Http1ServerConnectionImplTest, RejectInvalidMethod) { initialize(); - Http::MockStreamDecoder decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); std::string output; @@ -595,7 +591,7 @@ TEST_F(Http1ServerConnectionImplTest, BadRequestStartedStream) { std::string output; ON_CALL(connection_, write(_, _)).WillByDefault(AddBufferToString(&output)); - Http::MockStreamDecoder decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); Buffer::OwnedImpl buffer("G"); @@ -611,7 +607,7 @@ TEST_F(Http1ServerConnectionImplTest, HostHeaderTranslation) { InSequence sequence; - Http::MockStreamDecoder decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); TestHeaderMapImpl expected_headers{{":authority", "hello"}, {":path", "/"}, {":method", "GET"}}; @@ -633,7 +629,7 @@ TEST_F(Http1ServerConnectionImplTest, HeaderInvalidCharsRuntimeGuard) { initialize(); - Http::MockStreamDecoder decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); Buffer::OwnedImpl buffer( @@ -652,10 +648,10 @@ TEST_F(Http1ServerConnectionImplTest, HeaderInvalidCharsRejection) { initialize(); - Http::MockStreamDecoder decoder; - Http::StreamEncoder* response_encoder = nullptr; + MockRequestDecoder decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -671,10 +667,10 @@ TEST_F(Http1ServerConnectionImplTest, HeaderInvalidAuthority) { initialize(); - Http::MockStreamDecoder decoder; - Http::StreamEncoder* response_encoder = nullptr; + MockRequestDecoder decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -695,7 +691,7 @@ TEST_F(Http1ServerConnectionImplTest, HeaderEmbeddedNulRejection) { InSequence sequence; - Http::MockStreamDecoder decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); Buffer::OwnedImpl buffer( @@ -714,7 +710,7 @@ TEST_F(Http1ServerConnectionImplTest, HeaderMutateEmbeddedNul) { InSequence sequence; - Http::MockStreamDecoder decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); Buffer::OwnedImpl buffer( @@ -736,7 +732,7 @@ TEST_F(Http1ServerConnectionImplTest, HeaderMutateEmbeddedCRLF) { InSequence sequence; - NiceMock decoder; + NiceMock decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); Buffer::OwnedImpl buffer( @@ -754,7 +750,7 @@ TEST_F(Http1ServerConnectionImplTest, CloseDuringHeadersComplete) { InSequence sequence; - Http::MockStreamDecoder decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); TestHeaderMapImpl expected_headers{{"content-length", "5"}, {":path", "/"}, {":method", "POST"}}; @@ -774,7 +770,7 @@ TEST_F(Http1ServerConnectionImplTest, PostWithContentLength) { InSequence sequence; - Http::MockStreamDecoder decoder; + MockRequestDecoder decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); TestHeaderMapImpl expected_headers{{"content-length", "5"}, {":path", "/"}, {":method", "POST"}}; @@ -794,10 +790,10 @@ TEST_F(Http1ServerConnectionImplTest, PostWithContentLength) { TEST_F(Http1ServerConnectionImplTest, HeaderOnlyResponse) { initialize(); - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -819,10 +815,10 @@ TEST_F(Http1ServerConnectionImplTest, HeaderOnlyResponse) { TEST_F(Http1ServerConnectionImplTest, LargeHeaderResponseEncode) { initialize(); - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -845,10 +841,10 @@ TEST_F(Http1ServerConnectionImplTest, HeaderOnlyResponseTrainProperHeaders) { codec_settings_.header_key_format_ = Http1Settings::HeaderKeyFormat::ProperCase; initialize(); - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -869,10 +865,10 @@ TEST_F(Http1ServerConnectionImplTest, HeaderOnlyResponseTrainProperHeaders) { TEST_F(Http1ServerConnectionImplTest, HeaderOnlyResponseWith204) { initialize(); - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -892,10 +888,10 @@ TEST_F(Http1ServerConnectionImplTest, HeaderOnlyResponseWith204) { TEST_F(Http1ServerConnectionImplTest, HeaderOnlyResponseWith100Then200) { initialize(); - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -922,10 +918,10 @@ TEST_F(Http1ServerConnectionImplTest, HeaderOnlyResponseWith100Then200) { TEST_F(Http1ServerConnectionImplTest, MetadataTest) { initialize(); - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -944,10 +940,10 @@ TEST_F(Http1ServerConnectionImplTest, MetadataTest) { TEST_F(Http1ServerConnectionImplTest, ChunkedResponse) { initialize(); - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -973,10 +969,10 @@ TEST_F(Http1ServerConnectionImplTest, ChunkedResponse) { TEST_F(Http1ServerConnectionImplTest, ChunkedResponseWithTrailers) { codec_settings_.enable_trailers_ = true; initialize(); - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -1005,10 +1001,10 @@ TEST_F(Http1ServerConnectionImplTest, ChunkedResponseWithTrailers) { TEST_F(Http1ServerConnectionImplTest, ContentLengthResponse) { initialize(); - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -1031,10 +1027,10 @@ TEST_F(Http1ServerConnectionImplTest, ContentLengthResponse) { TEST_F(Http1ServerConnectionImplTest, HeadRequestResponse) { initialize(); - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -1054,10 +1050,10 @@ TEST_F(Http1ServerConnectionImplTest, HeadRequestResponse) { TEST_F(Http1ServerConnectionImplTest, HeadChunkedRequestResponse) { initialize(); - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -1077,11 +1073,11 @@ TEST_F(Http1ServerConnectionImplTest, HeadChunkedRequestResponse) { TEST_F(Http1ServerConnectionImplTest, DoubleRequest) { initialize(); - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) .Times(2) - .WillRepeatedly(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillRepeatedly(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -1144,7 +1140,7 @@ TEST_F(Http1ServerConnectionImplTest, UpgradeRequest) { initialize(); InSequence sequence; - NiceMock decoder; + NiceMock decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); EXPECT_CALL(decoder, decodeHeaders_(_, false)).Times(1); @@ -1167,7 +1163,7 @@ TEST_F(Http1ServerConnectionImplTest, UpgradeRequestWithEarlyData) { initialize(); InSequence sequence; - NiceMock decoder; + NiceMock decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); Buffer::OwnedImpl expected_data("12345abcd"); @@ -1182,7 +1178,7 @@ TEST_F(Http1ServerConnectionImplTest, UpgradeRequestWithTEChunked) { initialize(); InSequence sequence; - NiceMock decoder; + NiceMock decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); // Even with T-E chunked, the data should neither be inspected for (the not @@ -1199,7 +1195,7 @@ TEST_F(Http1ServerConnectionImplTest, UpgradeRequestWithNoBody) { initialize(); InSequence sequence; - NiceMock decoder; + NiceMock decoder; EXPECT_CALL(callbacks_, newStream(_, _)).WillOnce(ReturnRef(decoder)); // Make sure we avoid the deferred_end_stream_headers_ optimization for @@ -1216,10 +1212,10 @@ TEST_F(Http1ServerConnectionImplTest, WatermarkTest) { EXPECT_CALL(connection_, bufferLimit()).Times(1).WillOnce(Return(10)); initialize(); - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -1266,8 +1262,8 @@ class Http1ClientConnectionImplTest : public testing::Test { TEST_F(Http1ClientConnectionImplTest, SimpleGet) { initialize(); - Http::MockStreamDecoder response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + MockResponseDecoder response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); std::string output; ON_CALL(connection_, write(_, _)).WillByDefault(AddBufferToString(&output)); @@ -1282,8 +1278,8 @@ TEST_F(Http1ClientConnectionImplTest, SimpleGetWithHeaderCasing) { initialize(); - Http::MockStreamDecoder response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + MockResponseDecoder response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); std::string output; ON_CALL(connection_, write(_, _)).WillByDefault(AddBufferToString(&output)); @@ -1296,8 +1292,8 @@ TEST_F(Http1ClientConnectionImplTest, SimpleGetWithHeaderCasing) { TEST_F(Http1ClientConnectionImplTest, HostHeaderTranslate) { initialize(); - Http::MockStreamDecoder response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + MockResponseDecoder response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); std::string output; ON_CALL(connection_, write(_, _)).WillByDefault(AddBufferToString(&output)); @@ -1310,8 +1306,8 @@ TEST_F(Http1ClientConnectionImplTest, HostHeaderTranslate) { TEST_F(Http1ClientConnectionImplTest, Reset) { initialize(); - Http::MockStreamDecoder response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + MockResponseDecoder response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); Http::MockStreamCallbacks callbacks; request_encoder.getStream().addCallbacks(callbacks); @@ -1324,8 +1320,8 @@ TEST_F(Http1ClientConnectionImplTest, Reset) { TEST_F(Http1ClientConnectionImplTest, FlowControlReadDisabledReenable) { initialize(); - Http::MockStreamDecoder response_decoder; - Http::StreamEncoder* request_encoder = &codec_->newStream(response_decoder); + MockResponseDecoder response_decoder; + Http::RequestEncoder* request_encoder = &codec_->newStream(response_decoder); std::string output; ON_CALL(connection_, write(_, _)).WillByDefault(AddBufferToString(&output)); @@ -1372,8 +1368,8 @@ TEST_F(Http1ClientConnectionImplTest, PrematureResponse) { TEST_F(Http1ClientConnectionImplTest, EmptyBodyResponse503) { initialize(); - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); TestHeaderMapImpl headers{{":method", "GET"}, {":path", "/"}, {":authority", "host"}}; request_encoder.encodeHeaders(headers, true); @@ -1385,8 +1381,8 @@ TEST_F(Http1ClientConnectionImplTest, EmptyBodyResponse503) { TEST_F(Http1ClientConnectionImplTest, EmptyBodyResponse200) { initialize(); - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); TestHeaderMapImpl headers{{":method", "GET"}, {":path", "/"}, {":authority", "host"}}; request_encoder.encodeHeaders(headers, true); @@ -1398,8 +1394,8 @@ TEST_F(Http1ClientConnectionImplTest, EmptyBodyResponse200) { TEST_F(Http1ClientConnectionImplTest, HeadRequest) { initialize(); - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); TestHeaderMapImpl headers{{":method", "HEAD"}, {":path", "/"}, {":authority", "host"}}; request_encoder.encodeHeaders(headers, true); @@ -1411,8 +1407,8 @@ TEST_F(Http1ClientConnectionImplTest, HeadRequest) { TEST_F(Http1ClientConnectionImplTest, 204Response) { initialize(); - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); TestHeaderMapImpl headers{{":method", "GET"}, {":path", "/"}, {":authority", "host"}}; request_encoder.encodeHeaders(headers, true); @@ -1424,8 +1420,8 @@ TEST_F(Http1ClientConnectionImplTest, 204Response) { TEST_F(Http1ClientConnectionImplTest, 100Response) { initialize(); - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); TestHeaderMapImpl headers{{":method", "GET"}, {":path", "/"}, {":authority", "host"}}; request_encoder.encodeHeaders(headers, true); @@ -1443,10 +1439,10 @@ TEST_F(Http1ClientConnectionImplTest, 100Response) { TEST_F(Http1ClientConnectionImplTest, BadEncodeParams) { initialize(); - NiceMock response_decoder; + NiceMock response_decoder; // Need to set :method and :path - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); EXPECT_THROW(request_encoder.encodeHeaders(TestHeaderMapImpl{{":path", "/"}}, true), CodecClientException); EXPECT_THROW(request_encoder.encodeHeaders(TestHeaderMapImpl{{":method", "GET"}}, true), @@ -1456,8 +1452,8 @@ TEST_F(Http1ClientConnectionImplTest, BadEncodeParams) { TEST_F(Http1ClientConnectionImplTest, NoContentLengthResponse) { initialize(); - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); TestHeaderMapImpl headers{{":method", "GET"}, {":path", "/"}, {":authority", "host"}}; request_encoder.encodeHeaders(headers, true); @@ -1477,8 +1473,8 @@ TEST_F(Http1ClientConnectionImplTest, NoContentLengthResponse) { TEST_F(Http1ClientConnectionImplTest, ResponseWithTrailers) { initialize(); - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); TestHeaderMapImpl headers{{":method", "GET"}, {":path", "/"}, {":authority", "host"}}; request_encoder.encodeHeaders(headers, true); @@ -1491,8 +1487,8 @@ TEST_F(Http1ClientConnectionImplTest, ResponseWithTrailers) { TEST_F(Http1ClientConnectionImplTest, GiantPath) { initialize(); - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); TestHeaderMapImpl headers{ {":method", "GET"}, {":path", "/" + std::string(16384, 'a')}, {":authority", "host"}}; request_encoder.encodeHeaders(headers, true); @@ -1507,8 +1503,8 @@ TEST_F(Http1ClientConnectionImplTest, UpgradeResponse) { InSequence s; - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); TestHeaderMapImpl headers{{":method", "GET"}, {":path", "/"}, {":authority", "host"}}; request_encoder.encodeHeaders(headers, true); @@ -1538,8 +1534,8 @@ TEST_F(Http1ClientConnectionImplTest, UpgradeResponseWithEarlyData) { InSequence s; - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); TestHeaderMapImpl headers{{":method", "GET"}, {":path", "/"}, {":authority", "host"}}; request_encoder.encodeHeaders(headers, true); @@ -1558,8 +1554,8 @@ TEST_F(Http1ClientConnectionImplTest, WatermarkTest) { InSequence s; - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); Http::MockStreamCallbacks stream_callbacks; request_encoder.getStream().addCallbacks(stream_callbacks); @@ -1592,8 +1588,8 @@ TEST_F(Http1ClientConnectionImplTest, HighwatermarkMultipleResponses) { InSequence s; - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); Http::MockStreamCallbacks stream_callbacks; request_encoder.getStream().addCallbacks(stream_callbacks); @@ -1659,10 +1655,10 @@ TEST_F(Http1ServerConnectionImplTest, LargeRequestHeadersSplitRejected) { initialize(); std::string exception_reason; - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -1687,10 +1683,10 @@ TEST_F(Http1ServerConnectionImplTest, ManyRequestHeadersSplitRejected) { initialize(); std::string exception_reason; - NiceMock decoder; - Http::StreamEncoder* response_encoder = nullptr; + NiceMock decoder; + Http::ResponseEncoder* response_encoder = nullptr; EXPECT_CALL(callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamEncoder& encoder, bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder = &encoder; return decoder; })); @@ -1729,8 +1725,8 @@ TEST_F(Http1ServerConnectionImplTest, ManyRequestHeadersAccepted) { TEST_F(Http1ClientConnectionImplTest, LargeResponseHeadersRejected) { initialize(); - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); TestHeaderMapImpl headers{{":method", "GET"}, {":path", "/"}, {":authority", "host"}}; request_encoder.encodeHeaders(headers, true); @@ -1745,8 +1741,8 @@ TEST_F(Http1ClientConnectionImplTest, LargeResponseHeadersRejected) { TEST_F(Http1ClientConnectionImplTest, LargeResponseHeadersAccepted) { initialize(); - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); TestHeaderMapImpl headers{{":method", "GET"}, {":path", "/"}, {":authority", "host"}}; request_encoder.encodeHeaders(headers, true); @@ -1762,9 +1758,9 @@ TEST_F(Http1ClientConnectionImplTest, LargeResponseHeadersAccepted) { TEST_F(Http1ClientConnectionImplTest, LargeMethodRequestEncode) { initialize(); - NiceMock response_decoder; + NiceMock response_decoder; const std::string long_method = std::string(79 * 1024, 'a'); - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); TestHeaderMapImpl headers{{":method", long_method}, {":path", "/"}, {":authority", "host"}}; std::string output; ON_CALL(connection_, write(_, _)).WillByDefault(AddBufferToString(&output)); @@ -1779,9 +1775,9 @@ TEST_F(Http1ClientConnectionImplTest, LargeMethodRequestEncode) { TEST_F(Http1ClientConnectionImplTest, LargePathRequestEncode) { initialize(); - NiceMock response_decoder; + NiceMock response_decoder; const std::string long_path = std::string(79 * 1024, '/'); - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); TestHeaderMapImpl headers{{":method", "GET"}, {":path", long_path}, {":authority", "host"}}; std::string output; ON_CALL(connection_, write(_, _)).WillByDefault(AddBufferToString(&output)); @@ -1794,8 +1790,8 @@ TEST_F(Http1ClientConnectionImplTest, LargePathRequestEncode) { TEST_F(Http1ClientConnectionImplTest, LargeHeaderRequestEncode) { initialize(); - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); const std::string long_header_value = std::string(79 * 1024, 'a'); TestHeaderMapImpl headers{ {":method", "GET"}, {"foo", long_header_value}, {":path", "/"}, {":authority", "host"}}; @@ -1811,8 +1807,8 @@ TEST_F(Http1ClientConnectionImplTest, LargeHeaderRequestEncode) { TEST_F(Http1ClientConnectionImplTest, ManyResponseHeadersRejected) { initialize(); - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); TestHeaderMapImpl headers{{":method", "GET"}, {":path", "/"}, {":authority", "host"}}; request_encoder.encodeHeaders(headers, true); @@ -1828,8 +1824,8 @@ TEST_F(Http1ClientConnectionImplTest, ManyResponseHeadersAccepted) { initialize(); - NiceMock response_decoder; - Http::StreamEncoder& request_encoder = codec_->newStream(response_decoder); + NiceMock response_decoder; + Http::RequestEncoder& request_encoder = codec_->newStream(response_decoder); TestHeaderMapImpl headers{{":method", "GET"}, {":path", "/"}, {":authority", "host"}}; request_encoder.encodeHeaders(headers, true); diff --git a/test/common/http/http1/conn_pool_legacy_test.cc b/test/common/http/http1/conn_pool_legacy_test.cc index adad3d7a83b7..1e25075e7431 100644 --- a/test/common/http/http1/conn_pool_legacy_test.cc +++ b/test/common/http/http1/conn_pool_legacy_test.cc @@ -203,14 +203,17 @@ struct ActiveTestRequest { EXPECT_CALL(callbacks_.pool_ready_, ready()); } - void startRequest() { callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); } + void startRequest() { + callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); + } Http1ConnPoolImplLegacyTest& parent_; size_t client_index_; - NiceMock outer_decoder_; + NiceMock outer_decoder_; Http::ConnectionPool::Cancellable* handle_{}; - NiceMock request_encoder_; - Http::StreamDecoder* inner_decoder_{}; + NiceMock request_encoder_; + Http::ResponseDecoder* inner_decoder_{}; ConnPoolCallbacks callbacks_; }; @@ -269,7 +272,7 @@ TEST_F(Http1ConnPoolImplLegacyTest, VerifyTimingStats) { * Test that buffer limits are set. */ TEST_F(Http1ConnPoolImplLegacyTest, VerifyBufferLimits) { - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); EXPECT_CALL(*cluster_, perConnectionBufferLimitBytes()).WillOnce(Return(8192)); @@ -299,7 +302,7 @@ TEST_F(Http1ConnPoolImplLegacyTest, VerifyCancelInCallback) { handle1->cancel(); })); - NiceMock outer_decoder; + NiceMock outer_decoder; // Create the first client. conn_pool_.expectClientCreate(); handle1 = conn_pool_.newStream(outer_decoder, callbacks1); @@ -346,13 +349,13 @@ TEST_F(Http1ConnPoolImplLegacyTest, MaxPendingRequests) { EXPECT_EQ(0U, cluster_->circuit_breakers_stats_.rq_pending_open_.value()); - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); EXPECT_NE(nullptr, handle); - NiceMock outer_decoder2; + NiceMock outer_decoder2; ConnPoolCallbacks callbacks2; EXPECT_CALL(callbacks2.pool_failure_, ready()); Http::ConnectionPool::Cancellable* handle2 = conn_pool_.newStream(outer_decoder2, callbacks2); @@ -377,7 +380,7 @@ TEST_F(Http1ConnPoolImplLegacyTest, ConnectFailure) { InSequence s; // Request 1 should kick off a new connection. - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); @@ -457,12 +460,12 @@ TEST_F(Http1ConnPoolImplLegacyTest, ConnectTimeout) { InSequence s; // Request 1 should kick off a new connection. - NiceMock outer_decoder1; + NiceMock outer_decoder1; ConnPoolCallbacks callbacks1; conn_pool_.expectClientCreate(); EXPECT_NE(nullptr, conn_pool_.newStream(outer_decoder1, callbacks1)); - NiceMock outer_decoder2; + NiceMock outer_decoder2; ConnPoolCallbacks callbacks2; EXPECT_CALL(callbacks1.pool_failure_, ready()).WillOnce(Invoke([&]() -> void { conn_pool_.expectClientCreate(); @@ -489,7 +492,7 @@ TEST_F(Http1ConnPoolImplLegacyTest, CancelBeforeBound) { InSequence s; // Request 1 should kick off a new connection. - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); @@ -511,14 +514,14 @@ TEST_F(Http1ConnPoolImplLegacyTest, DisconnectWhileBound) { InSequence s; // Request 1 should kick off a new connection. - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); EXPECT_NE(nullptr, handle); - NiceMock request_encoder; - Http::StreamDecoder* inner_decoder; + NiceMock request_encoder; + ResponseDecoder* inner_decoder; EXPECT_CALL(*conn_pool_.test_clients_[0].codec_, newStream(_)) .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks.pool_ready_, ready()); @@ -545,7 +548,7 @@ TEST_F(Http1ConnPoolImplLegacyTest, MaxConnections) { EXPECT_EQ(0U, cluster_->circuit_breakers_stats_.cx_open_.value()); // Request 1 should kick off a new connection. - NiceMock outer_decoder1; + NiceMock outer_decoder1; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder1, callbacks); @@ -553,7 +556,7 @@ TEST_F(Http1ConnPoolImplLegacyTest, MaxConnections) { EXPECT_NE(nullptr, handle); // Request 2 should not kick off a new connection. - NiceMock outer_decoder2; + NiceMock outer_decoder2; ConnPoolCallbacks callbacks2; handle = conn_pool_.newStream(outer_decoder2, callbacks2); EXPECT_EQ(1U, cluster_->stats_.upstream_cx_overflow_.value()); @@ -562,8 +565,8 @@ TEST_F(Http1ConnPoolImplLegacyTest, MaxConnections) { EXPECT_NE(nullptr, handle); // Connect event will bind to request 1. - NiceMock request_encoder; - Http::StreamDecoder* inner_decoder; + NiceMock request_encoder; + ResponseDecoder* inner_decoder; EXPECT_CALL(*conn_pool_.test_clients_[0].codec_, newStream(_)) .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks.pool_ready_, ready()); @@ -576,12 +579,14 @@ TEST_F(Http1ConnPoolImplLegacyTest, MaxConnections) { .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks2.pool_ready_, ready()); - callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); Http::HeaderMapPtr response_headers(new TestHeaderMapImpl{{":status", "200"}}); inner_decoder->decodeHeaders(std::move(response_headers), true); conn_pool_.expectAndRunUpstreamReady(); - callbacks2.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks2.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // N.B. clang_tidy insists that we use std::make_unique which can not infer std::initialize_list. response_headers = std::make_unique( std::initializer_list>{{":status", "200"}}); @@ -601,7 +606,7 @@ TEST_F(Http1ConnPoolImplLegacyTest, ConnectionCloseWithoutHeader) { InSequence s; // Request 1 should kick off a new connection. - NiceMock outer_decoder1; + NiceMock outer_decoder1; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder1, callbacks); @@ -609,7 +614,7 @@ TEST_F(Http1ConnPoolImplLegacyTest, ConnectionCloseWithoutHeader) { EXPECT_NE(nullptr, handle); // Request 2 should not kick off a new connection. - NiceMock outer_decoder2; + NiceMock outer_decoder2; ConnPoolCallbacks callbacks2; handle = conn_pool_.newStream(outer_decoder2, callbacks2); EXPECT_EQ(1U, cluster_->stats_.upstream_cx_overflow_.value()); @@ -617,8 +622,8 @@ TEST_F(Http1ConnPoolImplLegacyTest, ConnectionCloseWithoutHeader) { EXPECT_NE(nullptr, handle); // Connect event will bind to request 1. - NiceMock request_encoder; - Http::StreamDecoder* inner_decoder; + NiceMock request_encoder; + ResponseDecoder* inner_decoder; EXPECT_CALL(*conn_pool_.test_clients_[0].codec_, newStream(_)) .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks.pool_ready_, ready()); @@ -628,7 +633,8 @@ TEST_F(Http1ConnPoolImplLegacyTest, ConnectionCloseWithoutHeader) { // Finishing request 1 will schedule binding the connection to request 2. conn_pool_.expectEnableUpstreamReady(); - callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); Http::HeaderMapPtr response_headers(new TestHeaderMapImpl{{":status", "200"}}); inner_decoder->decodeHeaders(std::move(response_headers), true); @@ -645,7 +651,8 @@ TEST_F(Http1ConnPoolImplLegacyTest, ConnectionCloseWithoutHeader) { EXPECT_CALL(callbacks2.pool_ready_, ready()); conn_pool_.test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::Connected); - callbacks2.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks2.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // N.B. clang_tidy insists that we use std::make_unique which can not infer std::initialize_list. response_headers = std::make_unique( std::initializer_list>{{":status", "200"}}); @@ -663,21 +670,22 @@ TEST_F(Http1ConnPoolImplLegacyTest, ConnectionCloseHeader) { InSequence s; // Request 1 should kick off a new connection. - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); EXPECT_NE(nullptr, handle); - NiceMock request_encoder; - Http::StreamDecoder* inner_decoder; + NiceMock request_encoder; + ResponseDecoder* inner_decoder; EXPECT_CALL(*conn_pool_.test_clients_[0].codec_, newStream(_)) .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks.pool_ready_, ready()); conn_pool_.test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::Connected); - callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // Response with 'connection: close' which should cause the connection to go away. EXPECT_CALL(conn_pool_, onClientDestroy()); @@ -696,21 +704,22 @@ TEST_F(Http1ConnPoolImplLegacyTest, ProxyConnectionCloseHeader) { InSequence s; // Request 1 should kick off a new connection. - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); EXPECT_NE(nullptr, handle); - NiceMock request_encoder; - Http::StreamDecoder* inner_decoder; + NiceMock request_encoder; + ResponseDecoder* inner_decoder; EXPECT_CALL(*conn_pool_.test_clients_[0].codec_, newStream(_)) .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks.pool_ready_, ready()); conn_pool_.test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::Connected); - callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // Response with 'proxy-connection: close' which should cause the connection to go away. EXPECT_CALL(conn_pool_, onClientDestroy()); @@ -729,21 +738,22 @@ TEST_F(Http1ConnPoolImplLegacyTest, Http10NoConnectionKeepAlive) { InSequence s; // Request 1 should kick off a new connection. - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(Protocol::Http10); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); EXPECT_NE(nullptr, handle); - NiceMock request_encoder; - Http::StreamDecoder* inner_decoder; + NiceMock request_encoder; + ResponseDecoder* inner_decoder; EXPECT_CALL(*conn_pool_.test_clients_[0].codec_, newStream(_)) .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks.pool_ready_, ready()); conn_pool_.test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::Connected); - callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // Response without 'connection: keep-alive' which should cause the connection to go away. EXPECT_CALL(conn_pool_, onClientDestroy()); @@ -764,21 +774,22 @@ TEST_F(Http1ConnPoolImplLegacyTest, MaxRequestsPerConnection) { cluster_->max_requests_per_connection_ = 1; // Request 1 should kick off a new connection. - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); EXPECT_NE(nullptr, handle); - NiceMock request_encoder; - Http::StreamDecoder* inner_decoder; + NiceMock request_encoder; + ResponseDecoder* inner_decoder; EXPECT_CALL(*conn_pool_.test_clients_[0].codec_, newStream(_)) .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks.pool_ready_, ready()); conn_pool_.test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::Connected); - callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // Response with 'connection: close' which should cause the connection to go away. EXPECT_CALL(conn_pool_, onClientDestroy()); @@ -849,7 +860,7 @@ TEST_F(Http1ConnPoolImplLegacyTest, DrainWhileConnecting) { InSequence s; ReadyWatcher drained; - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); @@ -869,23 +880,24 @@ TEST_F(Http1ConnPoolImplLegacyTest, DrainWhileConnecting) { TEST_F(Http1ConnPoolImplLegacyTest, RemoteCloseToCompleteResponse) { InSequence s; - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); EXPECT_NE(nullptr, handle); - NiceMock request_encoder; - Http::StreamDecoder* inner_decoder; + NiceMock request_encoder; + ResponseDecoder* inner_decoder; EXPECT_CALL(*conn_pool_.test_clients_[0].connect_timer_, disableTimer()); EXPECT_CALL(*conn_pool_.test_clients_[0].codec_, newStream(_)) .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks.pool_ready_, ready()); conn_pool_.test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::Connected); - callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); - inner_decoder->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, false); + inner_decoder->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, false); Buffer::OwnedImpl dummy_data("12345"); inner_decoder->decodeData(dummy_data, false); diff --git a/test/common/http/http1/conn_pool_test.cc b/test/common/http/http1/conn_pool_test.cc index e06808ca7170..ddc8ddeb1285 100644 --- a/test/common/http/http1/conn_pool_test.cc +++ b/test/common/http/http1/conn_pool_test.cc @@ -202,14 +202,17 @@ struct ActiveTestRequest { EXPECT_CALL(callbacks_.pool_ready_, ready()); } - void startRequest() { callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); } + void startRequest() { + callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); + } Http1ConnPoolImplTest& parent_; size_t client_index_; - NiceMock outer_decoder_; + NiceMock outer_decoder_; Http::ConnectionPool::Cancellable* handle_{}; - NiceMock request_encoder_; - Http::StreamDecoder* inner_decoder_{}; + NiceMock request_encoder_; + Http::ResponseDecoder* inner_decoder_{}; ConnPoolCallbacks callbacks_; }; @@ -266,7 +269,7 @@ TEST_F(Http1ConnPoolImplTest, VerifyTimingStats) { * Test that buffer limits are set. */ TEST_F(Http1ConnPoolImplTest, VerifyBufferLimits) { - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); EXPECT_CALL(*cluster_, perConnectionBufferLimitBytes()).WillOnce(Return(8192)); @@ -296,7 +299,7 @@ TEST_F(Http1ConnPoolImplTest, VerifyCancelInCallback) { handle1->cancel(); })); - NiceMock outer_decoder; + NiceMock outer_decoder; // Create the first client. conn_pool_.expectClientCreate(); handle1 = conn_pool_.newStream(outer_decoder, callbacks1); @@ -343,13 +346,13 @@ TEST_F(Http1ConnPoolImplTest, MaxPendingRequests) { EXPECT_EQ(0U, cluster_->circuit_breakers_stats_.rq_pending_open_.value()); - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); EXPECT_NE(nullptr, handle); - NiceMock outer_decoder2; + NiceMock outer_decoder2; ConnPoolCallbacks callbacks2; EXPECT_CALL(callbacks2.pool_failure_, ready()); Http::ConnectionPool::Cancellable* handle2 = conn_pool_.newStream(outer_decoder2, callbacks2); @@ -374,7 +377,7 @@ TEST_F(Http1ConnPoolImplTest, ConnectFailure) { InSequence s; // Request 1 should kick off a new connection. - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); @@ -454,12 +457,12 @@ TEST_F(Http1ConnPoolImplTest, ConnectTimeout) { InSequence s; // Request 1 should kick off a new connection. - NiceMock outer_decoder1; + NiceMock outer_decoder1; ConnPoolCallbacks callbacks1; conn_pool_.expectClientCreate(); EXPECT_NE(nullptr, conn_pool_.newStream(outer_decoder1, callbacks1)); - NiceMock outer_decoder2; + NiceMock outer_decoder2; ConnPoolCallbacks callbacks2; EXPECT_CALL(callbacks1.pool_failure_, ready()).WillOnce(Invoke([&]() -> void { conn_pool_.expectClientCreate(); @@ -486,7 +489,7 @@ TEST_F(Http1ConnPoolImplTest, CancelBeforeBound) { InSequence s; // Request 1 should kick off a new connection. - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); @@ -508,14 +511,14 @@ TEST_F(Http1ConnPoolImplTest, DisconnectWhileBound) { InSequence s; // Request 1 should kick off a new connection. - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); EXPECT_NE(nullptr, handle); - NiceMock request_encoder; - Http::StreamDecoder* inner_decoder; + NiceMock request_encoder; + ResponseDecoder* inner_decoder; EXPECT_CALL(*conn_pool_.test_clients_[0].codec_, newStream(_)) .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks.pool_ready_, ready()); @@ -542,7 +545,7 @@ TEST_F(Http1ConnPoolImplTest, MaxConnections) { EXPECT_EQ(0U, cluster_->circuit_breakers_stats_.cx_open_.value()); // Request 1 should kick off a new connection. - NiceMock outer_decoder1; + NiceMock outer_decoder1; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder1, callbacks); @@ -550,7 +553,7 @@ TEST_F(Http1ConnPoolImplTest, MaxConnections) { EXPECT_NE(nullptr, handle); // Request 2 should not kick off a new connection. - NiceMock outer_decoder2; + NiceMock outer_decoder2; ConnPoolCallbacks callbacks2; handle = conn_pool_.newStream(outer_decoder2, callbacks2); EXPECT_EQ(1U, cluster_->stats_.upstream_cx_overflow_.value()); @@ -559,8 +562,8 @@ TEST_F(Http1ConnPoolImplTest, MaxConnections) { EXPECT_NE(nullptr, handle); // Connect event will bind to request 1. - NiceMock request_encoder; - Http::StreamDecoder* inner_decoder; + NiceMock request_encoder; + ResponseDecoder* inner_decoder; EXPECT_CALL(*conn_pool_.test_clients_[0].codec_, newStream(_)) .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks.pool_ready_, ready()); @@ -573,12 +576,14 @@ TEST_F(Http1ConnPoolImplTest, MaxConnections) { .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks2.pool_ready_, ready()); - callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); Http::HeaderMapPtr response_headers(new TestHeaderMapImpl{{":status", "200"}}); inner_decoder->decodeHeaders(std::move(response_headers), true); conn_pool_.expectAndRunUpstreamReady(); - callbacks2.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks2.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // N.B. clang_tidy insists that we use std::make_unique which can not infer std::initialize_list. response_headers = std::make_unique( std::initializer_list>{{":status", "200"}}); @@ -598,7 +603,7 @@ TEST_F(Http1ConnPoolImplTest, ConnectionCloseWithoutHeader) { InSequence s; // Request 1 should kick off a new connection. - NiceMock outer_decoder1; + NiceMock outer_decoder1; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder1, callbacks); @@ -606,7 +611,7 @@ TEST_F(Http1ConnPoolImplTest, ConnectionCloseWithoutHeader) { EXPECT_NE(nullptr, handle); // Request 2 should not kick off a new connection. - NiceMock outer_decoder2; + NiceMock outer_decoder2; ConnPoolCallbacks callbacks2; handle = conn_pool_.newStream(outer_decoder2, callbacks2); EXPECT_EQ(1U, cluster_->stats_.upstream_cx_overflow_.value()); @@ -614,8 +619,8 @@ TEST_F(Http1ConnPoolImplTest, ConnectionCloseWithoutHeader) { EXPECT_NE(nullptr, handle); // Connect event will bind to request 1. - NiceMock request_encoder; - Http::StreamDecoder* inner_decoder; + NiceMock request_encoder; + ResponseDecoder* inner_decoder; EXPECT_CALL(*conn_pool_.test_clients_[0].codec_, newStream(_)) .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks.pool_ready_, ready()); @@ -625,7 +630,8 @@ TEST_F(Http1ConnPoolImplTest, ConnectionCloseWithoutHeader) { // Finishing request 1 will schedule binding the connection to request 2. conn_pool_.expectEnableUpstreamReady(); - callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); Http::HeaderMapPtr response_headers(new TestHeaderMapImpl{{":status", "200"}}); inner_decoder->decodeHeaders(std::move(response_headers), true); @@ -642,7 +648,8 @@ TEST_F(Http1ConnPoolImplTest, ConnectionCloseWithoutHeader) { EXPECT_CALL(callbacks2.pool_ready_, ready()); conn_pool_.test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::Connected); - callbacks2.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks2.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // N.B. clang_tidy insists that we use std::make_unique which can not infer std::initialize_list. response_headers = std::make_unique( std::initializer_list>{{":status", "200"}}); @@ -660,21 +667,22 @@ TEST_F(Http1ConnPoolImplTest, ConnectionCloseHeader) { InSequence s; // Request 1 should kick off a new connection. - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); EXPECT_NE(nullptr, handle); - NiceMock request_encoder; - Http::StreamDecoder* inner_decoder; + NiceMock request_encoder; + ResponseDecoder* inner_decoder; EXPECT_CALL(*conn_pool_.test_clients_[0].codec_, newStream(_)) .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks.pool_ready_, ready()); conn_pool_.test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::Connected); - callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // Response with 'connection: close' which should cause the connection to go away. EXPECT_CALL(conn_pool_, onClientDestroy()); @@ -693,21 +701,22 @@ TEST_F(Http1ConnPoolImplTest, ProxyConnectionCloseHeader) { InSequence s; // Request 1 should kick off a new connection. - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); EXPECT_NE(nullptr, handle); - NiceMock request_encoder; - Http::StreamDecoder* inner_decoder; + NiceMock request_encoder; + ResponseDecoder* inner_decoder; EXPECT_CALL(*conn_pool_.test_clients_[0].codec_, newStream(_)) .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks.pool_ready_, ready()); conn_pool_.test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::Connected); - callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // Response with 'proxy-connection: close' which should cause the connection to go away. EXPECT_CALL(conn_pool_, onClientDestroy()); @@ -726,21 +735,22 @@ TEST_F(Http1ConnPoolImplTest, Http10NoConnectionKeepAlive) { InSequence s; // Request 1 should kick off a new connection. - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(Protocol::Http10); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); EXPECT_NE(nullptr, handle); - NiceMock request_encoder; - Http::StreamDecoder* inner_decoder; + NiceMock request_encoder; + ResponseDecoder* inner_decoder; EXPECT_CALL(*conn_pool_.test_clients_[0].codec_, newStream(_)) .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks.pool_ready_, ready()); conn_pool_.test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::Connected); - callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // Response without 'connection: keep-alive' which should cause the connection to go away. EXPECT_CALL(conn_pool_, onClientDestroy()); @@ -761,21 +771,22 @@ TEST_F(Http1ConnPoolImplTest, MaxRequestsPerConnection) { cluster_->max_requests_per_connection_ = 1; // Request 1 should kick off a new connection. - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); EXPECT_NE(nullptr, handle); - NiceMock request_encoder; - Http::StreamDecoder* inner_decoder; + NiceMock request_encoder; + ResponseDecoder* inner_decoder; EXPECT_CALL(*conn_pool_.test_clients_[0].codec_, newStream(_)) .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks.pool_ready_, ready()); conn_pool_.test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::Connected); - callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // Response with 'connection: close' which should cause the connection to go away. EXPECT_CALL(conn_pool_, onClientDestroy()); @@ -846,7 +857,7 @@ TEST_F(Http1ConnPoolImplTest, DrainWhileConnecting) { InSequence s; ReadyWatcher drained; - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); @@ -865,23 +876,24 @@ TEST_F(Http1ConnPoolImplTest, DrainWhileConnecting) { TEST_F(Http1ConnPoolImplTest, RemoteCloseToCompleteResponse) { InSequence s; - NiceMock outer_decoder; + NiceMock outer_decoder; ConnPoolCallbacks callbacks; conn_pool_.expectClientCreate(); Http::ConnectionPool::Cancellable* handle = conn_pool_.newStream(outer_decoder, callbacks); EXPECT_NE(nullptr, handle); - NiceMock request_encoder; - Http::StreamDecoder* inner_decoder; + NiceMock request_encoder; + ResponseDecoder* inner_decoder; EXPECT_CALL(*conn_pool_.test_clients_[0].codec_, newStream(_)) .WillOnce(DoAll(SaveArgAddress(&inner_decoder), ReturnRef(request_encoder))); EXPECT_CALL(callbacks.pool_ready_, ready()); EXPECT_CALL(*conn_pool_.test_clients_[0].connect_timer_, disableTimer()); conn_pool_.test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::Connected); - callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{}, true); + callbacks.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); - inner_decoder->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, false); + inner_decoder->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, false); Buffer::OwnedImpl dummy_data("12345"); inner_decoder->decodeData(dummy_data, false); diff --git a/test/common/http/http2/codec_impl_test.cc b/test/common/http/http2/codec_impl_test.cc index 85e95250da6c..9c049d2734c7 100644 --- a/test/common/http/http2/codec_impl_test.cc +++ b/test/common/http/http2/codec_impl_test.cc @@ -75,7 +75,7 @@ class Http2CodecImplTestFixture { setupDefaultConnectionMocks(); EXPECT_CALL(server_callbacks_, newStream(_, _)) - .WillRepeatedly(Invoke([&](StreamEncoder& encoder, bool) -> StreamDecoder& { + .WillRepeatedly(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder_ = &encoder; encoder.getStream().addCallbacks(server_stream_callbacks_); return request_decoder_; @@ -146,10 +146,10 @@ class Http2CodecImplTestFixture { MockServerConnectionCallbacks server_callbacks_; std::unique_ptr server_; ConnectionWrapper server_wrapper_; - MockStreamDecoder response_decoder_; - StreamEncoder* request_encoder_; - MockStreamDecoder request_decoder_; - StreamEncoder* response_encoder_{}; + MockResponseDecoder response_decoder_; + RequestEncoder* request_encoder_; + MockRequestDecoder request_decoder_; + ResponseEncoder* response_encoder_{}; MockStreamCallbacks server_stream_callbacks_; // Corrupt a metadata frame payload. bool corrupt_metadata_frame_ = false; @@ -741,16 +741,16 @@ TEST_P(Http2CodecImplFlowControlTest, TestFlowControlInPendingSendData) { // Now create a second stream on the connection. MockStreamDecoder response_decoder2; - StreamEncoder* request_encoder2 = &client_->newStream(response_decoder_); + RequestEncoder* request_encoder2 = &client_->newStream(response_decoder_); StreamEncoder* response_encoder2; MockStreamCallbacks server_stream_callbacks2; - MockStreamDecoder request_decoder2; + MockRequestDecoder request_decoder2; // When the server stream is created it should check the status of the // underlying connection. Pretend it is overrun. EXPECT_CALL(server_connection_, aboveHighWatermark()).WillOnce(Return(true)); EXPECT_CALL(server_stream_callbacks2, onAboveWriteBufferHighWatermark()); EXPECT_CALL(server_callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](StreamEncoder& encoder, bool) -> StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder2 = &encoder; encoder.getStream().addCallbacks(server_stream_callbacks2); return request_decoder2; @@ -937,7 +937,7 @@ TEST_P(Http2CodecImplStreamLimitTest, MaxClientStreams) { request_encoder_ = &client_->newStream(response_decoder_); setupDefaultConnectionMocks(); EXPECT_CALL(server_callbacks_, newStream(_, _)) - .WillOnce(Invoke([&](StreamEncoder& encoder, bool) -> StreamDecoder& { + .WillOnce(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { response_encoder_ = &encoder; encoder.getStream().addCallbacks(server_stream_callbacks_); return request_decoder_; diff --git a/test/common/http/http2/conn_pool_legacy_test.cc b/test/common/http/http2/conn_pool_legacy_test.cc index ffc5339e9d2b..1521d5d9e661 100644 --- a/test/common/http/http2/conn_pool_legacy_test.cc +++ b/test/common/http/http2/conn_pool_legacy_test.cc @@ -152,10 +152,10 @@ class ActiveTestRequest { } } - Http::MockStreamDecoder decoder_; + MockResponseDecoder decoder_; ConnPoolCallbacks callbacks_; - Http::StreamDecoder* inner_decoder_{}; - NiceMock inner_encoder_; + ResponseDecoder* inner_decoder_{}; + NiceMock inner_encoder_; }; void Http2ConnPoolImplLegacyTest::expectClientConnect(size_t index, ActiveTestRequest& r) { @@ -188,9 +188,10 @@ void Http2ConnPoolImplLegacyTest::closeClient(size_t index) { void Http2ConnPoolImplLegacyTest::completeRequest(ActiveTestRequest& r) { EXPECT_CALL(r.inner_encoder_, encodeHeaders(_, true)); - r.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r.decoder_, decodeHeaders_(_, true)); - r.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); } void Http2ConnPoolImplLegacyTest::completeRequestCloseUpstream(size_t index, ActiveTestRequest& r) { @@ -217,13 +218,15 @@ TEST_F(Http2ConnPoolImplLegacyTest, DrainConnections) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); expectClientCreate(); ActiveTestRequest r2(*this, 1, false); expectClientConnect(1, r2); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // This will move primary to draining and destroy draining. pool_.drainConnections(); @@ -256,13 +259,16 @@ TEST_F(Http2ConnPoolImplLegacyTest, PendingRequests) { // Send a request through each stream. EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r3.inner_encoder_, encodeHeaders(_, true)); - r3.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r3.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // Since we now have an active connection, subsequent requests should connect immediately. ActiveTestRequest r4(*this, 0, true); @@ -362,7 +368,7 @@ TEST_F(Http2ConnPoolImplLegacyTest, PendingRequestsMaxPendingCircuitBreaker) { expectClientCreate(); ActiveTestRequest r1(*this, 0, false); - Http::MockStreamDecoder decoder; + MockResponseDecoder decoder; ConnPoolCallbacks callbacks; EXPECT_CALL(callbacks.pool_failure_, ready()); EXPECT_EQ(nullptr, pool_.newStream(decoder, callbacks)); @@ -391,9 +397,10 @@ TEST_F(Http2ConnPoolImplLegacyTest, VerifyConnectionTimingStats) { deliverHistogramToSinks(Property(&Stats::Metric::name, "upstream_cx_connect_ms"), _)); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r1.decoder_, decodeHeaders_(_, true)); - r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); EXPECT_CALL(*this, onClientDestroy()); @@ -415,9 +422,10 @@ TEST_F(Http2ConnPoolImplLegacyTest, VerifyBufferLimits) { expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r1.decoder_, decodeHeaders_(_, true)); - r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); EXPECT_CALL(*this, onClientDestroy()); @@ -434,15 +442,17 @@ TEST_F(Http2ConnPoolImplLegacyTest, RequestAndResponse) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r1.decoder_, decodeHeaders_(_, true)); - r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); ActiveTestRequest r2(*this, 0, true); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r2.decoder_, decodeHeaders_(_, true)); - r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); EXPECT_CALL(*this, onClientDestroy()); @@ -459,7 +469,8 @@ TEST_F(Http2ConnPoolImplLegacyTest, LocalReset) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, false)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, false); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + false); r1.callbacks_.outer_encoder_->getStream().resetStream(Http::StreamResetReason::LocalReset); test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); @@ -478,7 +489,8 @@ TEST_F(Http2ConnPoolImplLegacyTest, RemoteReset) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, false)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, false); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + false); r1.inner_encoder_.stream_.resetStream(Http::StreamResetReason::RemoteReset); test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); @@ -498,7 +510,8 @@ TEST_F(Http2ConnPoolImplLegacyTest, DrainDisconnectWithActiveRequest) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); ReadyWatcher drained; pool_.addDrainedCallback([&]() -> void { drained.ready(); }); @@ -521,20 +534,22 @@ TEST_F(Http2ConnPoolImplLegacyTest, DrainDisconnectDrainingWithActiveRequest) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); expectClientCreate(); ActiveTestRequest r2(*this, 1, false); expectClientConnect(1, r2); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); ReadyWatcher drained; pool_.addDrainedCallback([&]() -> void { drained.ready(); }); EXPECT_CALL(dispatcher_, deferredDelete_(_)); EXPECT_CALL(r2.decoder_, decodeHeaders_(_, true)); - r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); EXPECT_CALL(*this, onClientDestroy()); dispatcher_.clearDeferredDeleteList(); @@ -556,27 +571,29 @@ TEST_F(Http2ConnPoolImplLegacyTest, DrainPrimary) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); expectClientCreate(); ActiveTestRequest r2(*this, 1, false); expectClientConnect(1, r2); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); ReadyWatcher drained; pool_.addDrainedCallback([&]() -> void { drained.ready(); }); EXPECT_CALL(dispatcher_, deferredDelete_(_)); EXPECT_CALL(r2.decoder_, decodeHeaders_(_, true)); - r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); EXPECT_CALL(*this, onClientDestroy()); dispatcher_.clearDeferredDeleteList(); EXPECT_CALL(dispatcher_, deferredDelete_(_)); EXPECT_CALL(drained, ready()); EXPECT_CALL(r1.decoder_, decodeHeaders_(_, true)); - r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); EXPECT_CALL(*this, onClientDestroy()); dispatcher_.clearDeferredDeleteList(); @@ -590,9 +607,10 @@ TEST_F(Http2ConnPoolImplLegacyTest, DrainPrimaryNoActiveRequest) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r1.decoder_, decodeHeaders_(_, true)); - r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); EXPECT_CALL(dispatcher_, deferredDelete_(_)); expectClientCreate(); @@ -601,9 +619,10 @@ TEST_F(Http2ConnPoolImplLegacyTest, DrainPrimaryNoActiveRequest) { EXPECT_CALL(*this, onClientDestroy()); dispatcher_.clearDeferredDeleteList(); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r2.decoder_, decodeHeaders_(_, true)); - r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); ReadyWatcher drained; EXPECT_CALL(dispatcher_, deferredDelete_(_)); @@ -633,9 +652,10 @@ TEST_F(Http2ConnPoolImplLegacyTest, ConnectTimeout) { ActiveTestRequest r2(*this, 1, false); expectClientConnect(1, r2); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r2.decoder_, decodeHeaders_(_, true)); - r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); test_clients_[1].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); EXPECT_CALL(*this, onClientDestroy()); @@ -658,10 +678,11 @@ TEST_F(Http2ConnPoolImplLegacyTest, MaxGlobalRequests) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); ConnPoolCallbacks callbacks; - Http::MockStreamDecoder decoder; + MockResponseDecoder decoder; EXPECT_CALL(callbacks.pool_failure_, ready()); EXPECT_EQ(nullptr, pool_.newStream(decoder, callbacks)); @@ -680,9 +701,10 @@ TEST_F(Http2ConnPoolImplLegacyTest, GoAway) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r1.decoder_, decodeHeaders_(_, true)); - r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); test_clients_[0].codec_client_->raiseGoAway(); @@ -690,9 +712,10 @@ TEST_F(Http2ConnPoolImplLegacyTest, GoAway) { ActiveTestRequest r2(*this, 1, false); expectClientConnect(1, r2); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r2.decoder_, decodeHeaders_(_, true)); - r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); test_clients_[1].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); diff --git a/test/common/http/http2/conn_pool_test.cc b/test/common/http/http2/conn_pool_test.cc index 55386371c08c..f6de88d1855c 100644 --- a/test/common/http/http2/conn_pool_test.cc +++ b/test/common/http/http2/conn_pool_test.cc @@ -152,10 +152,10 @@ class ActiveTestRequest { } } - Http::MockStreamDecoder decoder_; + MockResponseDecoder decoder_; ConnPoolCallbacks callbacks_; - Http::StreamDecoder* inner_decoder_{}; - NiceMock inner_encoder_; + ResponseDecoder* inner_decoder_{}; + NiceMock inner_encoder_; ConnectionPool::Cancellable* handle_{}; }; @@ -189,9 +189,10 @@ void Http2ConnPoolImplTest::closeClient(size_t index) { void Http2ConnPoolImplTest::completeRequest(ActiveTestRequest& r) { EXPECT_CALL(r.inner_encoder_, encodeHeaders(_, true)); - r.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r.decoder_, decodeHeaders_(_, true)); - r.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); } void Http2ConnPoolImplTest::completeRequestCloseUpstream(size_t index, ActiveTestRequest& r) { @@ -230,13 +231,14 @@ TEST_F(Http2ConnPoolImplTest, DrainConnectionReadyWithRequest) { ActiveTestRequest r(*this, 0, false); expectClientConnect(0, r); EXPECT_CALL(r.inner_encoder_, encodeHeaders(_, true)); - r.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); pool_.drainConnections(); EXPECT_CALL(r.decoder_, decodeHeaders_(_, true)); EXPECT_CALL(*this, onClientDestroy()); - r.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); } /** @@ -251,13 +253,14 @@ TEST_F(Http2ConnPoolImplTest, DrainConnectionBusy) { ActiveTestRequest r(*this, 0, false); expectClientConnect(0, r); EXPECT_CALL(r.inner_encoder_, encodeHeaders(_, true)); - r.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); pool_.drainConnections(); EXPECT_CALL(r.decoder_, decodeHeaders_(_, true)); EXPECT_CALL(*this, onClientDestroy()); - r.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); } /** @@ -296,7 +299,8 @@ TEST_F(Http2ConnPoolImplTest, DrainConnections) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // With max_streams == 1, the second request moves the first connection // to draining. @@ -304,7 +308,8 @@ TEST_F(Http2ConnPoolImplTest, DrainConnections) { ActiveTestRequest r2(*this, 1, false); expectClientConnect(1, r2); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // This will move the second connection to draining. pool_.drainConnections(); @@ -389,13 +394,16 @@ TEST_F(Http2ConnPoolImplTest, PendingRequests) { // Send a request through each stream. EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r3.inner_encoder_, encodeHeaders(_, true)); - r3.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r3.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // Since we now have an active connection, subsequent requests should connect immediately. ActiveTestRequest r4(*this, 0, true); @@ -430,13 +438,16 @@ TEST_F(Http2ConnPoolImplTest, PendingRequestsNumberConnectingTotalRequestsPerCon // Send a request through each stream. EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r3.inner_encoder_, encodeHeaders(_, true)); - r3.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r3.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // Clean up everything. test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); @@ -466,13 +477,16 @@ TEST_F(Http2ConnPoolImplTest, PendingRequestsNumberConnectingConcurrentRequestsP // Send a request through each stream. EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r3.inner_encoder_, encodeHeaders(_, true)); - r3.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r3.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); // Clean up everything. test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); @@ -567,7 +581,7 @@ TEST_F(Http2ConnPoolImplTest, PendingRequestsMaxPendingCircuitBreaker) { expectClientCreate(); ActiveTestRequest r1(*this, 0, false); - Http::MockStreamDecoder decoder; + MockResponseDecoder decoder; ConnPoolCallbacks callbacks; EXPECT_CALL(callbacks.pool_failure_, ready()); EXPECT_EQ(nullptr, pool_.newStream(decoder, callbacks)); @@ -596,9 +610,10 @@ TEST_F(Http2ConnPoolImplTest, VerifyConnectionTimingStats) { deliverHistogramToSinks(Property(&Stats::Metric::name, "upstream_cx_connect_ms"), _)); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r1.decoder_, decodeHeaders_(_, true)); - r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); EXPECT_CALL(cluster_->stats_store_, deliverHistogramToSinks(Property(&Stats::Metric::name, "upstream_cx_length_ms"), _)); @@ -620,9 +635,10 @@ TEST_F(Http2ConnPoolImplTest, VerifyBufferLimits) { expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r1.decoder_, decodeHeaders_(_, true)); - r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); EXPECT_CALL(*this, onClientDestroy()); @@ -639,16 +655,18 @@ TEST_F(Http2ConnPoolImplTest, RequestAndResponse) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_EQ(1U, cluster_->stats_.upstream_cx_active_.value()); EXPECT_CALL(r1.decoder_, decodeHeaders_(_, true)); - r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); ActiveTestRequest r2(*this, 0, true); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r2.decoder_, decodeHeaders_(_, true)); - r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); EXPECT_CALL(*this, onClientDestroy()); @@ -666,7 +684,8 @@ TEST_F(Http2ConnPoolImplTest, LocalReset) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, false)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, false); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + false); r1.callbacks_.outer_encoder_->getStream().resetStream(Http::StreamResetReason::LocalReset); test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); @@ -686,7 +705,8 @@ TEST_F(Http2ConnPoolImplTest, RemoteReset) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, false)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, false); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + false); r1.inner_encoder_.stream_.resetStream(Http::StreamResetReason::RemoteReset); test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); @@ -707,7 +727,8 @@ TEST_F(Http2ConnPoolImplTest, DrainDisconnectWithActiveRequest) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); ReadyWatcher drained; pool_.addDrainedCallback([&]() -> void { drained.ready(); }); @@ -732,20 +753,22 @@ TEST_F(Http2ConnPoolImplTest, DrainDisconnectDrainingWithActiveRequest) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); expectClientCreate(); ActiveTestRequest r2(*this, 1, false); expectClientConnect(1, r2); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); ReadyWatcher drained; pool_.addDrainedCallback([&]() -> void { drained.ready(); }); EXPECT_CALL(dispatcher_, deferredDelete_(_)); EXPECT_CALL(r2.decoder_, decodeHeaders_(_, true)); - r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); EXPECT_CALL(*this, onClientDestroy()); dispatcher_.clearDeferredDeleteList(); @@ -769,27 +792,29 @@ TEST_F(Http2ConnPoolImplTest, DrainPrimary) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); expectClientCreate(); ActiveTestRequest r2(*this, 1, false); expectClientConnect(1, r2); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); ReadyWatcher drained; pool_.addDrainedCallback([&]() -> void { drained.ready(); }); EXPECT_CALL(dispatcher_, deferredDelete_(_)); EXPECT_CALL(r2.decoder_, decodeHeaders_(_, true)); - r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); EXPECT_CALL(*this, onClientDestroy()); dispatcher_.clearDeferredDeleteList(); EXPECT_CALL(dispatcher_, deferredDelete_(_)); EXPECT_CALL(drained, ready()); EXPECT_CALL(r1.decoder_, decodeHeaders_(_, true)); - r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); EXPECT_CALL(*this, onClientDestroy()); dispatcher_.clearDeferredDeleteList(); @@ -805,10 +830,11 @@ TEST_F(Http2ConnPoolImplTest, DrainPrimaryNoActiveRequest) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(dispatcher_, deferredDelete_(_)); EXPECT_CALL(r1.decoder_, decodeHeaders_(_, true)); - r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); expectClientCreate(); ActiveTestRequest r2(*this, 1, false); @@ -816,10 +842,11 @@ TEST_F(Http2ConnPoolImplTest, DrainPrimaryNoActiveRequest) { EXPECT_CALL(*this, onClientDestroy()); dispatcher_.clearDeferredDeleteList(); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(dispatcher_, deferredDelete_(_)); EXPECT_CALL(r2.decoder_, decodeHeaders_(_, true)); - r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); ReadyWatcher drained; EXPECT_CALL(drained, ready()); @@ -848,9 +875,10 @@ TEST_F(Http2ConnPoolImplTest, ConnectTimeout) { ActiveTestRequest r2(*this, 1, false); expectClientConnect(1, r2); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r2.decoder_, decodeHeaders_(_, true)); - r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); test_clients_[1].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); EXPECT_CALL(*this, onClientDestroy()); @@ -873,10 +901,11 @@ TEST_F(Http2ConnPoolImplTest, MaxGlobalRequests) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); ConnPoolCallbacks callbacks; - Http::MockStreamDecoder decoder; + MockResponseDecoder decoder; EXPECT_CALL(callbacks.pool_failure_, ready()); EXPECT_EQ(nullptr, pool_.newStream(decoder, callbacks)); @@ -895,9 +924,10 @@ TEST_F(Http2ConnPoolImplTest, GoAway) { ActiveTestRequest r1(*this, 0, false); expectClientConnect(0, r1); EXPECT_CALL(r1.inner_encoder_, encodeHeaders(_, true)); - r1.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r1.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r1.decoder_, decodeHeaders_(_, true)); - r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r1.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); test_clients_[0].codec_client_->raiseGoAway(); @@ -905,9 +935,10 @@ TEST_F(Http2ConnPoolImplTest, GoAway) { ActiveTestRequest r2(*this, 1, false); expectClientConnect(1, r2); EXPECT_CALL(r2.inner_encoder_, encodeHeaders(_, true)); - r2.callbacks_.outer_encoder_->encodeHeaders(HeaderMapImpl{}, true); + r2.callbacks_.outer_encoder_->encodeHeaders(TestHeaderMapImpl{{":path", "/"}, {":method", "GET"}}, + true); EXPECT_CALL(r2.decoder_, decodeHeaders_(_, true)); - r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new HeaderMapImpl{}}, true); + r2.inner_decoder_->decodeHeaders(HeaderMapPtr{new TestHeaderMapImpl{{":status", "200"}}}, true); test_clients_[1].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); test_clients_[0].connection_->raiseEvent(Network::ConnectionEvent::RemoteClose); diff --git a/test/common/http/http2/frame_replay.cc b/test/common/http/http2/frame_replay.cc index e7f846954a69..fb6d5f94688d 100644 --- a/test/common/http/http2/frame_replay.cc +++ b/test/common/http/http2/frame_replay.cc @@ -78,7 +78,7 @@ ClientCodecFrameInjector::ClientCodecFrameInjector() : CodecFrameInjector("serve ServerCodecFrameInjector::ServerCodecFrameInjector() : CodecFrameInjector("client") { EXPECT_CALL(server_callbacks_, newStream(_, _)) - .WillRepeatedly(Invoke([&](StreamEncoder& encoder, bool) -> StreamDecoder& { + .WillRepeatedly(Invoke([&](ResponseEncoder& encoder, bool) -> RequestDecoder& { encoder.getStream().addCallbacks(server_stream_callbacks_); return request_decoder_; })); diff --git a/test/common/http/http2/frame_replay.h b/test/common/http/http2/frame_replay.h index 4ab12bd93a38..afa9c6014ebf 100644 --- a/test/common/http/http2/frame_replay.h +++ b/test/common/http/http2/frame_replay.h @@ -68,8 +68,8 @@ class ClientCodecFrameInjector : public CodecFrameInjector { ::testing::NiceMock client_connection_; MockConnectionCallbacks client_callbacks_; - MockStreamDecoder response_decoder_; - StreamEncoder* request_encoder_; + MockResponseDecoder response_decoder_; + RequestEncoder* request_encoder_; MockStreamCallbacks client_stream_callbacks_; }; @@ -81,7 +81,7 @@ class ServerCodecFrameInjector : public CodecFrameInjector { ::testing::NiceMock server_connection_; MockServerConnectionCallbacks server_callbacks_; - MockStreamDecoder request_decoder_; + MockRequestDecoder request_decoder_; MockStreamCallbacks server_stream_callbacks_; }; diff --git a/test/common/router/router_test.cc b/test/common/router/router_test.cc index 7f90c3af1533..5dea1a94524d 100644 --- a/test/common/router/router_test.cc +++ b/test/common/router/router_test.cc @@ -209,7 +209,7 @@ class RouterTestBase : public testing::Test { } EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) .WillOnce(Invoke( - [&](Http::StreamDecoder& decoder, + [&](Http::ResponseDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { response_decoder_ = &decoder; EXPECT_CALL(callbacks_.dispatcher_, setTrackedObject(_)).Times(testing::AtLeast(2)); @@ -272,10 +272,10 @@ class RouterTestBase : public testing::Test { Event::MockTimer* per_try_timeout_{}; Network::Address::InstanceConstSharedPtr host_address_{ Network::Utility::resolveUrl("tcp://10.0.0.5:9211")}; - NiceMock original_encoder_; - NiceMock second_encoder_; + NiceMock original_encoder_; + NiceMock second_encoder_; NiceMock connection_; - Http::StreamDecoder* response_decoder_ = nullptr; + Http::ResponseDecoder* response_decoder_ = nullptr; Http::TestHeaderMapImpl default_request_headers_{}; Http::HeaderMapPtr redirect_headers_{ new Http::TestHeaderMapImpl{{":status", "302"}, {"location", "http://www.foo.com"}}}; @@ -499,16 +499,17 @@ TEST_F(RouterTest, HashKeyNoHashPolicy) { TEST_F(RouterTest, AddCookie) { ON_CALL(callbacks_.route_->route_entry_, hashPolicy()) .WillByDefault(Return(&callbacks_.route_->route_entry_.hash_policy_)); - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return &cancellable_; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return &cancellable_; + })); EXPECT_CALL(cm_, httpConnPoolForCluster(_, _, _, _)) .WillOnce( @@ -548,16 +549,17 @@ TEST_F(RouterTest, AddCookie) { TEST_F(RouterTest, AddCookieNoDuplicate) { ON_CALL(callbacks_.route_->route_entry_, hashPolicy()) .WillByDefault(Return(&callbacks_.route_->route_entry_.hash_policy_)); - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return &cancellable_; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return &cancellable_; + })); EXPECT_CALL(cm_, httpConnPoolForCluster(_, _, _, _)) .WillOnce( @@ -595,16 +597,17 @@ TEST_F(RouterTest, AddCookieNoDuplicate) { TEST_F(RouterTest, AddMultipleCookies) { ON_CALL(callbacks_.route_->route_entry_, hashPolicy()) .WillByDefault(Return(&callbacks_.route_->route_entry_.hash_policy_)); - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return &cancellable_; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return &cancellable_; + })); EXPECT_CALL(cm_, httpConnPoolForCluster(_, _, _, _)) .WillOnce( @@ -780,15 +783,16 @@ TEST_F(RouterTestSuppressEnvoyHeaders, MaintenanceMode) { } TEST_F(RouterTest, ResponseCodeDetailsSetByUpstream) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers; @@ -805,15 +809,16 @@ TEST_F(RouterTest, ResponseCodeDetailsSetByUpstream) { // Validate that x-envoy-upstream-service-time is added on a regular // request/response path. TEST_F(RouterTest, EnvoyUpstreamServiceTime) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers; @@ -844,15 +849,16 @@ void RouterTestBase::testAppendCluster(absl::optional clu StreamInfo::FilterState::StateType::ReadOnly, StreamInfo::FilterState::LifeSpan::FilterChain); - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers; @@ -897,15 +903,16 @@ void RouterTestBase::testAppendUpstreamHost( StreamInfo::FilterState::LifeSpan::FilterChain); cm_.conn_pool_.host_->hostname_ = "scooby.doo"; - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers; @@ -1020,15 +1027,16 @@ TEST_F(RouterTest, AllDebugConfig) { // TODO(htuch): Probably should be TEST_P with // RouterTest.EnvoyUpstreamServiceTime, this is getting verbose.. TEST_F(RouterTestSuppressEnvoyHeaders, EnvoyUpstreamServiceTime) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers; @@ -1048,15 +1056,16 @@ TEST_F(RouterTestSuppressEnvoyHeaders, EnvoyUpstreamServiceTime) { } TEST_F(RouterTest, NoRetriesOverflow) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"x-envoy-retry-on", "5xx"}, {"x-envoy-internal", "true"}}; @@ -1072,14 +1081,15 @@ TEST_F(RouterTest, NoRetriesOverflow) { // We expect the 5xx response to kick off a new request. EXPECT_CALL(encoder1.stream_, resetStream(_)).Times(0); - NiceMock encoder2; + NiceMock encoder2; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); router_.retry_state_->callback_(); // RetryOverflow kicks in. @@ -1094,15 +1104,16 @@ TEST_F(RouterTest, NoRetriesOverflow) { } TEST_F(RouterTest, ResetDuringEncodeHeaders) { - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); EXPECT_CALL(callbacks_, removeDownstreamWatermarkCallbacks(_)); EXPECT_CALL(callbacks_, addDownstreamWatermarkCallbacks(_)); @@ -1124,15 +1135,16 @@ TEST_F(RouterTest, ResetDuringEncodeHeaders) { } TEST_F(RouterTest, UpstreamTimeout) { - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); EXPECT_CALL(callbacks_.stream_info_, onUpstreamHostSelected(_)) .WillOnce(Invoke([&](const Upstream::HostDescriptionConstSharedPtr host) -> void { EXPECT_EQ(host_address_, host->address()); @@ -1168,15 +1180,16 @@ TEST_F(RouterTest, UpstreamTimeout) { // Verify the timeout budget histograms are filled out correctly when using a // global and per-try timeout in a successful request. TEST_F(RouterTest, TimeoutBudgetHistogramStat) { - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectPerTryTimerCreate(); expectResponseTimerCreate(); @@ -1207,15 +1220,16 @@ TEST_F(RouterTest, TimeoutBudgetHistogramStat) { // Verify the timeout budget histograms are filled out correctly when using a // global and per-try timeout in a failed request. TEST_F(RouterTest, TimeoutBudgetHistogramStatFailure) { - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectPerTryTimerCreate(); expectResponseTimerCreate(); @@ -1245,15 +1259,16 @@ TEST_F(RouterTest, TimeoutBudgetHistogramStatFailure) { // Verify the timeout budget histograms are filled out correctly when only using a global timeout. TEST_F(RouterTest, TimeoutBudgetHistogramStatOnlyGlobal) { - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectPerTryTimerCreate(); Http::TestHeaderMapImpl headers{{"x-envoy-upstream-rq-timeout-ms", "200"}}; @@ -1281,15 +1296,16 @@ TEST_F(RouterTest, TimeoutBudgetHistogramStatOnlyGlobal) { // Verify the timeout budget histograms are filled out correctly across retries. TEST_F(RouterTest, TimeoutBudgetHistogramStatDuringRetries) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder1 = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder1 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder1 = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder1 = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectPerTryTimerCreate(); expectResponseTimerCreate(); @@ -1322,15 +1338,16 @@ TEST_F(RouterTest, TimeoutBudgetHistogramStatDuringRetries) { // We expect the 5xx response to kick off a new request. EXPECT_CALL(encoder1.stream_, resetStream(_)).Times(0); - NiceMock encoder2; - Http::StreamDecoder* response_decoder2 = nullptr; + NiceMock encoder2; + Http::ResponseDecoder* response_decoder2 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder2 = &decoder; - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder2 = &decoder; + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectPerTryTimerCreate(); router_.retry_state_->callback_(); @@ -1369,15 +1386,16 @@ TEST_F(RouterTest, TimeoutBudgetHistogramStatDuringRetries) { // Verify the timeout budget histograms are filled out correctly when the global timeout occurs // during a retry. TEST_F(RouterTest, TimeoutBudgetHistogramStatDuringGlobalTimeout) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder1 = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder1 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder1 = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder1 = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectPerTryTimerCreate(); expectResponseTimerCreate(); @@ -1410,15 +1428,16 @@ TEST_F(RouterTest, TimeoutBudgetHistogramStatDuringGlobalTimeout) { // We expect the 5xx response to kick off a new request. EXPECT_CALL(encoder1.stream_, resetStream(_)).Times(0); - NiceMock encoder2; - Http::StreamDecoder* response_decoder2 = nullptr; + NiceMock encoder2; + Http::ResponseDecoder* response_decoder2 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder2 = &decoder; - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder2 = &decoder; + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectPerTryTimerCreate(); router_.retry_state_->callback_(); @@ -1457,15 +1476,16 @@ TEST_F(RouterTest, TimeoutBudgetHistogramStatDuringGlobalTimeout) { // Validate gRPC OK response stats are sane when response is trailers only. TEST_F(RouterTest, GrpcOkTrailersOnly) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"content-type", "application/grpc"}, {"grpc-timeout", "20S"}}; @@ -1481,15 +1501,16 @@ TEST_F(RouterTest, GrpcOkTrailersOnly) { // Validate gRPC AlreadyExists response stats are sane when response is trailers only. TEST_F(RouterTest, GrpcAlreadyExistsTrailersOnly) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"content-type", "application/grpc"}, {"grpc-timeout", "20S"}}; @@ -1505,15 +1526,16 @@ TEST_F(RouterTest, GrpcAlreadyExistsTrailersOnly) { // Validate gRPC Unavailable response stats are sane when response is trailers only. TEST_F(RouterTest, GrpcOutlierDetectionUnavailableStatusCode) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"content-type", "application/grpc"}, {"grpc-timeout", "20S"}}; @@ -1530,15 +1552,16 @@ TEST_F(RouterTest, GrpcOutlierDetectionUnavailableStatusCode) { // Validate gRPC Internal response stats are sane when response is trailers only. TEST_F(RouterTest, GrpcInternalTrailersOnly) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"content-type", "application/grpc"}, {"grpc-timeout", "20S"}}; @@ -1555,15 +1578,16 @@ TEST_F(RouterTest, GrpcInternalTrailersOnly) { // Validate gRPC response stats are sane when response is ended in a DATA // frame. TEST_F(RouterTest, GrpcDataEndStream) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"content-type", "application/grpc"}, {"grpc-timeout", "20S"}}; @@ -1582,15 +1606,16 @@ TEST_F(RouterTest, GrpcDataEndStream) { // Validate gRPC response stats are sane when response is reset after initial // response HEADERS. TEST_F(RouterTest, GrpcReset) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"content-type", "application/grpc"}, {"grpc-timeout", "20S"}}; @@ -1610,15 +1635,16 @@ TEST_F(RouterTest, GrpcReset) { // Validate gRPC OK response stats are sane when response is not trailers only. TEST_F(RouterTest, GrpcOk) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"content-type", "application/grpc"}, {"grpc-timeout", "20S"}}; @@ -1639,15 +1665,16 @@ TEST_F(RouterTest, GrpcOk) { // Validate gRPC Internal response stats are sane when response is not trailers only. TEST_F(RouterTest, GrpcInternal) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"content-type", "application/grpc"}, {"grpc-timeout", "20S"}}; @@ -1664,15 +1691,16 @@ TEST_F(RouterTest, GrpcInternal) { } TEST_F(RouterTest, UpstreamTimeoutWithAltResponse) { - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); EXPECT_CALL(callbacks_.stream_info_, onUpstreamHostSelected(_)) .WillOnce(Invoke([&](const Upstream::HostDescriptionConstSharedPtr host) -> void { EXPECT_EQ(host_address_, host->address()); @@ -1707,15 +1735,16 @@ TEST_F(RouterTest, UpstreamTimeoutWithAltResponse) { // Verifies that the per try timeout is initialized once the downstream request has been read. TEST_F(RouterTest, UpstreamPerTryTimeout) { - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); EXPECT_CALL(callbacks_.stream_info_, onUpstreamHostSelected(_)) .WillOnce(Invoke([&](const Upstream::HostDescriptionConstSharedPtr host) -> void { EXPECT_EQ(host_address_, host->address()); @@ -1756,16 +1785,17 @@ TEST_F(RouterTest, UpstreamPerTryTimeout) { // Verifies that the per try timeout starts when onPoolReady is called when it occurs // after the downstream request has been read. TEST_F(RouterTest, UpstreamPerTryTimeoutDelayedPoolReady) { - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; Http::ConnectionPool::Callbacks* pool_callbacks; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - pool_callbacks = &callbacks; - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + pool_callbacks = &callbacks; + return nullptr; + })); Http::TestHeaderMapImpl headers{{"x-envoy-internal", "true"}, {"x-envoy-upstream-rq-per-try-timeout-ms", "5"}}; @@ -1807,17 +1837,18 @@ TEST_F(RouterTest, UpstreamPerTryTimeoutDelayedPoolReady) { // Ensures that the per try callback is not set until the stream becomes available. TEST_F(RouterTest, UpstreamPerTryTimeoutExcludesNewStream) { InSequence s; - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; Http::ConnectionPool::Callbacks* pool_callbacks; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - pool_callbacks = &callbacks; - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + pool_callbacks = &callbacks; + return nullptr; + })); response_timeout_ = new Event::MockTimer(&callbacks_.dispatcher_); EXPECT_CALL(*response_timeout_, enableTimer(_, _)); @@ -1865,16 +1896,17 @@ TEST_F(RouterTest, UpstreamPerTryTimeoutExcludesNewStream) { TEST_F(RouterTest, HedgedPerTryTimeoutFirstRequestSucceeds) { enableHedgeOnPerTryTimeout(); - NiceMock encoder1; - Http::StreamDecoder* response_decoder1 = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder1 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder1 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder1 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); EXPECT_CALL(cm_.conn_pool_.host_->outlier_detector_, putResult(Upstream::Outlier::Result::LocalOriginConnectSuccess, absl::optional(absl::nullopt))) @@ -1890,19 +1922,20 @@ TEST_F(RouterTest, HedgedPerTryTimeoutFirstRequestSucceeds) { cm_.conn_pool_.host_->outlier_detector_, putResult(Upstream::Outlier::Result::LocalOriginTimeout, absl::optional(504))); EXPECT_CALL(encoder1.stream_, resetStream(_)).Times(0); - NiceMock encoder2; - Http::StreamDecoder* response_decoder2 = nullptr; + NiceMock encoder2; + Http::ResponseDecoder* response_decoder2 = nullptr; router_.retry_state_->expectHedgedPerTryTimeoutRetry(); per_try_timeout_->invokeCallback(); EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder2 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder2 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectPerTryTimerCreate(); router_.retry_state_->callback_(); @@ -1938,16 +1971,17 @@ TEST_F(RouterTest, HedgedPerTryTimeoutFirstRequestSucceeds) { TEST_F(RouterTest, HedgedPerTryTimeoutResetsOnBadHeaders) { enableHedgeOnPerTryTimeout(); - NiceMock encoder1; - Http::StreamDecoder* response_decoder1 = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder1 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder1 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder1 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); EXPECT_CALL(cm_.conn_pool_.host_->outlier_detector_, putResult(Upstream::Outlier::Result::LocalOriginConnectSuccess, absl::optional(absl::nullopt))) @@ -1963,19 +1997,20 @@ TEST_F(RouterTest, HedgedPerTryTimeoutResetsOnBadHeaders) { cm_.conn_pool_.host_->outlier_detector_, putResult(Upstream::Outlier::Result::LocalOriginTimeout, absl::optional(504))); EXPECT_CALL(encoder1.stream_, resetStream(_)).Times(0); - NiceMock encoder2; - Http::StreamDecoder* response_decoder2 = nullptr; + NiceMock encoder2; + Http::ResponseDecoder* response_decoder2 = nullptr; router_.retry_state_->expectHedgedPerTryTimeoutRetry(); per_try_timeout_->invokeCallback(); EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder2 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder2 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectPerTryTimerCreate(); router_.retry_state_->callback_(); @@ -2016,16 +2051,17 @@ TEST_F(RouterTest, HedgedPerTryTimeoutResetsOnBadHeaders) { TEST_F(RouterTest, HedgedPerTryTimeoutThirdRequestSucceeds) { enableHedgeOnPerTryTimeout(); - NiceMock encoder1; - Http::StreamDecoder* response_decoder1 = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder1 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder1 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder1 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); expectPerTryTimerCreate(); @@ -2047,16 +2083,17 @@ TEST_F(RouterTest, HedgedPerTryTimeoutThirdRequestSucceeds) { router_.retry_state_->expectHeadersRetry(); response_decoder1->decodeHeaders(std::move(response_headers1), true); - NiceMock encoder2; - Http::StreamDecoder* response_decoder2 = nullptr; + NiceMock encoder2; + Http::ResponseDecoder* response_decoder2 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder2 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder2 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectPerTryTimerCreate(); router_.retry_state_->callback_(); @@ -2067,16 +2104,17 @@ TEST_F(RouterTest, HedgedPerTryTimeoutThirdRequestSucceeds) { EXPECT_CALL( cm_.conn_pool_.host_->outlier_detector_, putResult(Upstream::Outlier::Result::LocalOriginTimeout, absl::optional(504))); - NiceMock encoder3; - Http::StreamDecoder* response_decoder3 = nullptr; + NiceMock encoder3; + Http::ResponseDecoder* response_decoder3 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder3 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder3, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder3 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder3, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); EXPECT_CALL(callbacks_, encodeHeaders_(_, _)).Times(0); per_try_timeout_->invokeCallback(); @@ -2109,16 +2147,17 @@ TEST_F(RouterTest, HedgedPerTryTimeoutThirdRequestSucceeds) { TEST_F(RouterTest, RetryOnlyOnceForSameUpstreamRequest) { enableHedgeOnPerTryTimeout(); - NiceMock encoder1; - Http::StreamDecoder* response_decoder1 = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder1 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder1 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder1 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); EXPECT_CALL(cm_.conn_pool_.host_->outlier_detector_, putResult(Upstream::Outlier::Result::LocalOriginConnectSuccess, absl::optional(absl::nullopt))) @@ -2138,16 +2177,17 @@ TEST_F(RouterTest, RetryOnlyOnceForSameUpstreamRequest) { router_.retry_state_->expectHedgedPerTryTimeoutRetry(); per_try_timeout_->invokeCallback(); - NiceMock encoder2; - Http::StreamDecoder* response_decoder2 = nullptr; + NiceMock encoder2; + Http::ResponseDecoder* response_decoder2 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder2 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder2 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectPerTryTimerCreate(); router_.retry_state_->callback_(); @@ -2173,16 +2213,17 @@ TEST_F(RouterTest, RetryOnlyOnceForSameUpstreamRequest) { TEST_F(RouterTest, BadHeadersDroppedIfPreviousRetryScheduled) { enableHedgeOnPerTryTimeout(); - NiceMock encoder1; - Http::StreamDecoder* response_decoder1 = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder1 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder1 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder1 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); EXPECT_CALL(cm_.conn_pool_.host_->outlier_detector_, putResult(Upstream::Outlier::Result::LocalOriginConnectSuccess, absl::optional(absl::nullopt))) @@ -2214,16 +2255,17 @@ TEST_F(RouterTest, BadHeadersDroppedIfPreviousRetryScheduled) { response_decoder1->decodeHeaders(std::move(response_headers1), true); // Now trigger the retry for the per try timeout earlier. - NiceMock encoder2; - Http::StreamDecoder* response_decoder2 = nullptr; + NiceMock encoder2; + Http::ResponseDecoder* response_decoder2 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder2 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder2 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); router_.retry_state_->callback_(); Http::HeaderMapPtr response_headers2(new Http::TestHeaderMapImpl{{":status", "200"}}); @@ -2238,15 +2280,16 @@ TEST_F(RouterTest, BadHeadersDroppedIfPreviousRetryScheduled) { } TEST_F(RouterTest, RetryRequestNotComplete) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); EXPECT_CALL(callbacks_.stream_info_, setResponseFlag(StreamInfo::ResponseFlag::UpstreamRemoteReset)); EXPECT_CALL(callbacks_.stream_info_, onUpstreamHostSelected(_)) @@ -2271,16 +2314,17 @@ TEST_F(RouterTest, RetryRequestNotComplete) { TEST_F(RouterTest, HedgedPerTryTimeoutGlobalTimeout) { enableHedgeOnPerTryTimeout(); - NiceMock encoder1; - Http::StreamDecoder* response_decoder1 = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder1 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder1 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder1 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); EXPECT_CALL(cm_.conn_pool_.host_->outlier_detector_, putResult(Upstream::Outlier::Result::LocalOriginConnectSuccess, absl::optional(absl::nullopt))) @@ -2300,16 +2344,17 @@ TEST_F(RouterTest, HedgedPerTryTimeoutGlobalTimeout) { router_.retry_state_->expectHedgedPerTryTimeoutRetry(); per_try_timeout_->invokeCallback(); - NiceMock encoder2; - Http::StreamDecoder* response_decoder2 = nullptr; + NiceMock encoder2; + Http::ResponseDecoder* response_decoder2 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder2 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder2 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectPerTryTimerCreate(); router_.retry_state_->callback_(); @@ -2337,16 +2382,17 @@ TEST_F(RouterTest, HedgedPerTryTimeoutGlobalTimeout) { TEST_F(RouterTest, HedgingRetriesExhaustedBadResponse) { enableHedgeOnPerTryTimeout(); - NiceMock encoder1; - Http::StreamDecoder* response_decoder1 = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder1 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder1 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder1 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); EXPECT_CALL(cm_.conn_pool_.host_->outlier_detector_, putResult(Upstream::Outlier::Result::LocalOriginConnectSuccess, absl::optional(absl::nullopt))) @@ -2366,16 +2412,17 @@ TEST_F(RouterTest, HedgingRetriesExhaustedBadResponse) { router_.retry_state_->expectHedgedPerTryTimeoutRetry(); per_try_timeout_->invokeCallback(); - NiceMock encoder2; - Http::StreamDecoder* response_decoder2 = nullptr; + NiceMock encoder2; + Http::ResponseDecoder* response_decoder2 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder2 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder2 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); EXPECT_CALL(cm_.conn_pool_.host_->outlier_detector_, putResult(Upstream::Outlier::Result::LocalOriginConnectSuccess, absl::optional(absl::nullopt))) @@ -2417,16 +2464,17 @@ TEST_F(RouterTest, HedgingRetriesExhaustedBadResponse) { TEST_F(RouterTest, HedgingRetriesProceedAfterReset) { enableHedgeOnPerTryTimeout(); - NiceMock encoder1; - Http::StreamDecoder* response_decoder1 = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder1 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder1 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder1 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); // First is reset EXPECT_CALL(cm_.conn_pool_.host_->outlier_detector_, putResult(Upstream::Outlier::Result::LocalOriginConnectFailed, _)) @@ -2450,16 +2498,17 @@ TEST_F(RouterTest, HedgingRetriesProceedAfterReset) { router_.retry_state_->expectHedgedPerTryTimeoutRetry(); per_try_timeout_->invokeCallback(); - NiceMock encoder2; - Http::StreamDecoder* response_decoder2 = nullptr; + NiceMock encoder2; + Http::ResponseDecoder* response_decoder2 = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder2 = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder2 = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectPerTryTimerCreate(); router_.retry_state_->callback_(); @@ -2496,16 +2545,17 @@ TEST_F(RouterTest, HedgingRetriesProceedAfterReset) { TEST_F(RouterTest, HedgingRetryImmediatelyReset) { enableHedgeOnPerTryTimeout(); - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); EXPECT_CALL(cm_.conn_pool_.host_->outlier_detector_, putResult(Upstream::Outlier::Result::LocalOriginConnectSuccess, absl::optional(absl::nullopt))) @@ -2530,7 +2580,7 @@ TEST_F(RouterTest, HedgingRetryImmediatelyReset) { EXPECT_CALL(callbacks_, encodeHeaders_(_, _)).Times(0); per_try_timeout_->invokeCallback(); - NiceMock encoder2; + NiceMock encoder2; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) .WillOnce(Invoke([&](Http::StreamDecoder&, Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { @@ -2565,15 +2615,16 @@ TEST_F(RouterTest, HedgingRetryImmediatelyReset) { } TEST_F(RouterTest, RetryNoneHealthy) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); EXPECT_CALL(callbacks_.stream_info_, onUpstreamHostSelected(_)) @@ -2602,15 +2653,16 @@ TEST_F(RouterTest, RetryNoneHealthy) { } TEST_F(RouterTest, RetryUpstreamReset) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"x-envoy-retry-on", "5xx"}, {"x-envoy-internal", "true"}}; @@ -2627,17 +2679,18 @@ TEST_F(RouterTest, RetryUpstreamReset) { encoder1.stream_.resetStream(Http::StreamResetReason::RemoteReset); // We expect this reset to kick off a new request. - NiceMock encoder2; + NiceMock encoder2; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - EXPECT_CALL(cm_.conn_pool_.host_->outlier_detector_, - putResult(Upstream::Outlier::Result::LocalOriginConnectSuccess, - absl::optional(absl::nullopt))); - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + EXPECT_CALL(cm_.conn_pool_.host_->outlier_detector_, + putResult(Upstream::Outlier::Result::LocalOriginConnectSuccess, + absl::optional(absl::nullopt))); + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); router_.retry_state_->callback_(); EXPECT_TRUE(verifyHostUpstreamStats(0, 1)); @@ -2650,15 +2703,16 @@ TEST_F(RouterTest, RetryUpstreamReset) { } TEST_F(RouterTest, NoRetryWithBodyLimit) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); // Set a per route body limit which disallows any buffering. EXPECT_CALL(callbacks_.route_->route_entry_, retryShadowBufferLimit()).WillOnce(Return(0)); @@ -2679,16 +2733,17 @@ TEST_F(RouterTest, NoRetryWithBodyLimit) { // before an upstream host has been established, then the onHostAttempted function will not be // invoked. This ensures that we're not passing a null host to the retry plugins. TEST_F(RouterTest, RetryUpstreamPerTryTimeout) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectPerTryTimerCreate(); expectResponseTimerCreate(); @@ -2705,18 +2760,19 @@ TEST_F(RouterTest, RetryUpstreamPerTryTimeout) { EXPECT_TRUE(verifyHostUpstreamStats(0, 1)); // We expect this reset to kick off a new request. - NiceMock encoder2; + NiceMock encoder2; EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - EXPECT_CALL(cm_.conn_pool_.host_->outlier_detector_, - putResult(Upstream::Outlier::Result::LocalOriginConnectSuccess, - absl::optional(absl::nullopt))); - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + EXPECT_CALL(cm_.conn_pool_.host_->outlier_detector_, + putResult(Upstream::Outlier::Result::LocalOriginConnectSuccess, + absl::optional(absl::nullopt))); + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectPerTryTimerCreate(); router_.retry_state_->callback_(); @@ -2751,17 +2807,18 @@ TEST_F(RouterTest, RetryUpstreamConnectionFailure) { conn_pool_callbacks->onPoolFailure(Http::ConnectionPool::PoolFailureReason::ConnectionFailure, absl::string_view(), nullptr); - Http::StreamDecoder* response_decoder = nullptr; + Http::ResponseDecoder* response_decoder = nullptr; // We expect this reset to kick off a new request. - NiceMock encoder2; + NiceMock encoder2; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); router_.retry_state_->callback_(); // Normal response. @@ -2773,15 +2830,16 @@ TEST_F(RouterTest, RetryUpstreamConnectionFailure) { } TEST_F(RouterTest, DontResetStartedResponseOnUpstreamPerTryTimeout) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectPerTryTimerCreate(); expectResponseTimerCreate(); @@ -2807,15 +2865,16 @@ TEST_F(RouterTest, DontResetStartedResponseOnUpstreamPerTryTimeout) { } TEST_F(RouterTest, RetryUpstreamResetResponseStarted) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"x-envoy-retry-on", "5xx"}, {"x-envoy-internal", "true"}}; @@ -2839,15 +2898,16 @@ TEST_F(RouterTest, RetryUpstreamResetResponseStarted) { } TEST_F(RouterTest, RetryUpstreamReset100ContinueResponseStarted) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"x-envoy-retry-on", "5xx"}, {"x-envoy-internal", "true"}}; @@ -2868,17 +2928,18 @@ TEST_F(RouterTest, RetryUpstreamReset100ContinueResponseStarted) { putResult(Upstream::Outlier::Result::LocalOriginConnectFailed, _)); encoder1.stream_.resetStream(Http::StreamResetReason::RemoteReset); } - -TEST_F(RouterTest, RetryUpstream5xx) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; - EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + +TEST_F(RouterTest, RetryUpstream5xx) { + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; + EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"x-envoy-retry-on", "5xx"}, {"x-envoy-internal", "true"}}; @@ -2894,14 +2955,15 @@ TEST_F(RouterTest, RetryUpstream5xx) { // We expect the 5xx response to kick off a new request. EXPECT_CALL(encoder1.stream_, resetStream(_)).Times(0); - NiceMock encoder2; + NiceMock encoder2; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); router_.retry_state_->callback_(); // Normal response. @@ -2914,15 +2976,16 @@ TEST_F(RouterTest, RetryUpstream5xx) { } TEST_F(RouterTest, RetryTimeoutDuringRetryDelay) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"x-envoy-retry-on", "5xx"}, {"x-envoy-internal", "true"}}; @@ -2950,15 +3013,16 @@ TEST_F(RouterTest, RetryTimeoutDuringRetryDelay) { } TEST_F(RouterTest, RetryTimeoutDuringRetryDelayWithUpstreamRequestNoHost) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"x-envoy-retry-on", "5xx"}, {"x-envoy-internal", "true"}}; @@ -2974,7 +3038,7 @@ TEST_F(RouterTest, RetryTimeoutDuringRetryDelayWithUpstreamRequestNoHost) { Http::ConnectionPool::MockCancellable cancellable; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, + .WillOnce(Invoke([&](Http::ResponseDecoder& decoder, Http::ConnectionPool::Callbacks&) -> Http::ConnectionPool::Cancellable* { response_decoder = &decoder; return &cancellable; @@ -2997,15 +3061,16 @@ TEST_F(RouterTest, RetryTimeoutDuringRetryDelayWithUpstreamRequestNoHost) { // Retry timeout during a retry delay leading to no upstream host, as well as an alt response code. TEST_F(RouterTest, RetryTimeoutDuringRetryDelayWithUpstreamRequestNoHostAltResponseCode) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"x-envoy-retry-on", "5xx"}, @@ -3023,7 +3088,7 @@ TEST_F(RouterTest, RetryTimeoutDuringRetryDelayWithUpstreamRequestNoHostAltRespo Http::ConnectionPool::MockCancellable cancellable; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, + .WillOnce(Invoke([&](Http::ResponseDecoder& decoder, Http::ConnectionPool::Callbacks&) -> Http::ConnectionPool::Cancellable* { response_decoder = &decoder; return &cancellable; @@ -3043,15 +3108,16 @@ TEST_F(RouterTest, RetryTimeoutDuringRetryDelayWithUpstreamRequestNoHostAltRespo } TEST_F(RouterTest, RetryUpstream5xxNotComplete) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"x-envoy-retry-on", "5xx"}, {"x-envoy-internal", "true"}}; @@ -3075,14 +3141,15 @@ TEST_F(RouterTest, RetryUpstream5xxNotComplete) { EXPECT_TRUE(verifyHostUpstreamStats(0, 1)); // We expect the 5xx response to kick off a new request. - NiceMock encoder2; + NiceMock encoder2; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); ON_CALL(callbacks_, decodingBuffer()).WillByDefault(Return(body_data.get())); EXPECT_CALL(encoder2, encodeHeaders(_, false)); EXPECT_CALL(encoder2, encodeData(_, false)); @@ -3115,15 +3182,16 @@ TEST_F(RouterTest, RetryUpstream5xxNotComplete) { // Validate gRPC Cancelled response stats are sane when retry is taking effect. TEST_F(RouterTest, RetryUpstreamGrpcCancelled) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"x-envoy-retry-grpc-on", "cancelled"}, @@ -3143,14 +3211,15 @@ TEST_F(RouterTest, RetryUpstreamGrpcCancelled) { // We expect the grpc-status to result in a retried request. EXPECT_CALL(encoder1.stream_, resetStream(_)).Times(0); - NiceMock encoder2; + NiceMock encoder2; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); router_.retry_state_->callback_(); // Normal response. @@ -3167,15 +3236,16 @@ TEST_F(RouterTest, RetryUpstreamGrpcCancelled) { TEST_F(RouterTest, RetryRespsectsMaxHostSelectionCount) { router_.reject_all_hosts_ = true; - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"x-envoy-retry-on", "5xx"}, {"x-envoy-internal", "true"}}; @@ -3203,14 +3273,15 @@ TEST_F(RouterTest, RetryRespsectsMaxHostSelectionCount) { EXPECT_TRUE(verifyHostUpstreamStats(0, 1)); // We expect the 5xx response to kick off a new request. - NiceMock encoder2; + NiceMock encoder2; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); ON_CALL(callbacks_, decodingBuffer()).WillByDefault(Return(body_data.get())); EXPECT_CALL(encoder2, encodeHeaders(_, false)); EXPECT_CALL(encoder2, encodeData(_, false)); @@ -3234,15 +3305,16 @@ TEST_F(RouterTest, RetryRespsectsMaxHostSelectionCount) { TEST_F(RouterTest, RetryRespectsRetryHostPredicate) { router_.reject_all_hosts_ = true; - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); Http::TestHeaderMapImpl headers{{"x-envoy-retry-on", "5xx"}, {"x-envoy-internal", "true"}}; @@ -3270,14 +3342,15 @@ TEST_F(RouterTest, RetryRespectsRetryHostPredicate) { EXPECT_TRUE(verifyHostUpstreamStats(0, 1)); // We expect the 5xx response to kick off a new request. - NiceMock encoder2; + NiceMock encoder2; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); ON_CALL(callbacks_, decodingBuffer()).WillByDefault(Return(body_data.get())); EXPECT_CALL(encoder2, encodeHeaders(_, false)); EXPECT_CALL(encoder2, encodeData(_, false)); @@ -3443,15 +3516,16 @@ TEST_F(RouterTest, Shadow) { callbacks_.route_->route_entry_.shadow_policies_.push_back(std::move(policy)); ON_CALL(callbacks_, streamId()).WillByDefault(Return(43)); - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); EXPECT_CALL(runtime_.snapshot_, featureEnabled("bar", 0, 43, 10000)).WillOnce(Return(true)); @@ -3494,15 +3568,16 @@ TEST_F(RouterTest, AltStatName) { .WillOnce(Return(std::chrono::milliseconds(0))); EXPECT_CALL(callbacks_.dispatcher_, createTimer_(_)).Times(0); - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); Http::TestHeaderMapImpl headers{{"x-envoy-upstream-alt-stat-name", "alt_stat"}, {"x-envoy-internal", "true"}}; @@ -3663,8 +3738,8 @@ TEST_F(RouterTest, DirectResponseWithoutLocation) { } TEST_F(RouterTest, UpstreamSSLConnection) { - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; std::string session_id = "D62A523A65695219D46FE1FFE285A4C371425ACE421B110B5B8D11D3EB4D5F0B"; auto connection_info = std::make_shared>(); @@ -3673,12 +3748,13 @@ TEST_F(RouterTest, UpstreamSSLConnection) { expectResponseTimerCreate(); EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); Http::TestHeaderMapImpl headers{}; HttpTestUtility::addDefaultHeaders(headers); @@ -3695,15 +3771,16 @@ TEST_F(RouterTest, UpstreamSSLConnection) { // Verify that upstream timing information is set into the StreamInfo after the upstream // request completes. TEST_F(RouterTest, UpstreamTimingSingleRequest) { - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); StreamInfo::StreamInfoImpl stream_info(test_time_.timeSystem()); @@ -3752,15 +3829,16 @@ TEST_F(RouterTest, UpstreamTimingSingleRequest) { // Verify that upstream timing information is set into the StreamInfo when a // retry occurs (and not before). TEST_F(RouterTest, UpstreamTimingRetry) { - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); StreamInfo::StreamInfoImpl stream_info(test_time_); @@ -3780,12 +3858,13 @@ TEST_F(RouterTest, UpstreamTimingRetry) { test_time_.sleep(std::chrono::milliseconds(43)); EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); // Check that upstream timing is not set when a retry will occur. Http::HeaderMapPtr bad_response_headers(new Http::TestHeaderMapImpl{{":status", "503"}}); @@ -3832,15 +3911,16 @@ TEST_F(RouterTest, UpstreamTimingRetry) { // Verify that upstream timing information is set into the StreamInfo when a // global timeout occurs. TEST_F(RouterTest, UpstreamTimingTimeout) { - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); StreamInfo::StreamInfoImpl stream_info(test_time_); ON_CALL(callbacks_, streamInfo()).WillByDefault(ReturnRef(stream_info)); @@ -4375,15 +4455,16 @@ TEST_F(RouterTest, CanaryStatusTrue) { .WillOnce(Return(std::chrono::milliseconds(0))); EXPECT_CALL(callbacks_.dispatcher_, createTimer_(_)).Times(0); - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); Http::TestHeaderMapImpl headers{{"x-envoy-upstream-alt-stat-name", "alt_stat"}, {"x-envoy-internal", "true"}}; @@ -4408,15 +4489,16 @@ TEST_F(RouterTest, CanaryStatusFalse) { .WillOnce(Return(std::chrono::milliseconds(0))); EXPECT_CALL(callbacks_.dispatcher_, createTimer_(_)).Times(0); - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); Http::TestHeaderMapImpl headers{{"x-envoy-upstream-alt-stat-name", "alt_stat"}, {"x-envoy-internal", "true"}}; @@ -4436,7 +4518,7 @@ TEST_F(RouterTest, CanaryStatusFalse) { } TEST_F(RouterTest, AutoHostRewriteEnabled) { - NiceMock encoder; + NiceMock encoder; std::string req_host{"foo.bar.com"}; Http::TestHeaderMapImpl incoming_headers; @@ -4474,7 +4556,7 @@ TEST_F(RouterTest, AutoHostRewriteEnabled) { } TEST_F(RouterTest, AutoHostRewriteDisabled) { - NiceMock encoder; + NiceMock encoder; std::string req_host{"foo.bar.com"}; Http::TestHeaderMapImpl incoming_headers; @@ -4574,7 +4656,7 @@ class WatermarkTest : public RouterTest { EXPECT_CALL(encoder_, getStream()).WillRepeatedly(ReturnRef(stream_)); EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) .WillOnce(Invoke( - [&](Http::StreamDecoder& decoder, + [&](Http::ResponseDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { response_decoder_ = &decoder; pool_callbacks_ = &callbacks; @@ -4591,10 +4673,10 @@ class WatermarkTest : public RouterTest { Http::HeaderMapPtr{new Http::TestHeaderMapImpl{{":status", "200"}}}, true); } - NiceMock encoder_; + NiceMock encoder_; NiceMock stream_; Http::StreamCallbacks* stream_callbacks_; - Http::StreamDecoder* response_decoder_ = nullptr; + Http::ResponseDecoder* response_decoder_ = nullptr; Http::TestHeaderMapImpl headers_; Http::ConnectionPool::Callbacks* pool_callbacks_{nullptr}; }; @@ -4683,11 +4765,11 @@ TEST_F(WatermarkTest, FilterWatermarks) { TEST_F(WatermarkTest, RetryRequestNotComplete) { EXPECT_CALL(callbacks_, decoderBufferLimit()).Times(2).WillRepeatedly(Return(10)); router_.setDecoderFilterCallbacks(callbacks_); - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) .WillRepeatedly(Invoke( - [&](Http::StreamDecoder& decoder, + [&](Http::ResponseDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { response_decoder = &decoder; callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); @@ -4729,17 +4811,18 @@ TEST_F(RouterTestChildSpan, BasicFlow) { .WillOnce(Return(std::chrono::milliseconds(0))); EXPECT_CALL(callbacks_.dispatcher_, createTimer_(_)).Times(0); - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; Tracing::MockSpan* child_span{new Tracing::MockSpan()}; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - EXPECT_CALL(*child_span, injectContext(_)); - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + EXPECT_CALL(*child_span, injectContext(_)); + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); Http::TestHeaderMapImpl headers; HttpTestUtility::addDefaultHeaders(headers); @@ -4768,17 +4851,18 @@ TEST_F(RouterTestChildSpan, ResetFlow) { .WillOnce(Return(std::chrono::milliseconds(0))); EXPECT_CALL(callbacks_.dispatcher_, createTimer_(_)).Times(0); - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; Tracing::MockSpan* child_span{new Tracing::MockSpan()}; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - EXPECT_CALL(*child_span, injectContext(_)); - callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + EXPECT_CALL(*child_span, injectContext(_)); + callbacks.onPoolReady(encoder, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); Http::TestHeaderMapImpl headers; HttpTestUtility::addDefaultHeaders(headers); @@ -4814,7 +4898,7 @@ TEST_F(RouterTestChildSpan, CancelFlow) { .WillOnce(Return(std::chrono::milliseconds(0))); EXPECT_CALL(callbacks_.dispatcher_, createTimer_(_)).Times(0); - NiceMock encoder; + NiceMock encoder; Tracing::MockSpan* child_span{new Tracing::MockSpan()}; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) .WillOnce(Invoke([&](Http::StreamDecoder&, Http::ConnectionPool::Callbacks& callbacks) @@ -4851,17 +4935,18 @@ TEST_F(RouterTestChildSpan, CancelFlow) { // The first request will fail because of an upstream reset, so the span will be annotated with the // reset reason. The second request will succeed, so the span will be annotated with 200 OK. TEST_F(RouterTestChildSpan, ResetRetryFlow) { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; Tracing::MockSpan* child_span_1{new Tracing::MockSpan()}; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - EXPECT_CALL(*child_span_1, injectContext(_)); - callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + EXPECT_CALL(*child_span_1, injectContext(_)); + callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); expectResponseTimerCreate(); // Upstream responds back to envoy simulating an upstream reset. @@ -4889,17 +4974,18 @@ TEST_F(RouterTestChildSpan, ResetRetryFlow) { encoder1.stream_.resetStream(Http::StreamResetReason::RemoteReset); // We expect this reset to kick off a new request. - NiceMock encoder2; + NiceMock encoder2; Tracing::MockSpan* child_span_2{new Tracing::MockSpan()}; EXPECT_CALL(cm_.conn_pool_, newStream(_, _)) - .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) - -> Http::ConnectionPool::Cancellable* { - response_decoder = &decoder; - EXPECT_CALL(*child_span_2, injectContext(_)); - EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); - callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); - return nullptr; - })); + .WillOnce(Invoke( + [&](Http::ResponseDecoder& decoder, + Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { + response_decoder = &decoder; + EXPECT_CALL(*child_span_2, injectContext(_)); + EXPECT_CALL(*router_.retry_state_, onHostAttempted(_)); + callbacks.onPoolReady(encoder2, cm_.conn_pool_.host_, upstream_stream_info_); + return nullptr; + })); EXPECT_CALL(callbacks_.active_span_, spawnChild_(_, "router fake_cluster egress", _)) .WillOnce(Return(child_span_2)); diff --git a/test/common/router/router_upstream_log_test.cc b/test/common/router/router_upstream_log_test.cc index 4fa5414671d3..ad40d7c9be12 100644 --- a/test/common/router/router_upstream_log_test.cc +++ b/test/common/router/router_upstream_log_test.cc @@ -125,12 +125,12 @@ class RouterUpstreamLogTest : public testing::Test { const std::initializer_list>& request_headers_init, const std::initializer_list>& response_headers_init, const std::initializer_list>& response_trailers_init) { - NiceMock encoder; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(context_.cluster_manager_.conn_pool_, newStream(_, _)) .WillOnce(Invoke( - [&](Http::StreamDecoder& decoder, + [&](Http::ResponseDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { response_decoder = &decoder; EXPECT_CALL(encoder.stream_, connectionLocalAddress()) @@ -161,12 +161,12 @@ class RouterUpstreamLogTest : public testing::Test { void run() { run(200, {}, {}, {}); } void runWithRetry() { - NiceMock encoder1; - Http::StreamDecoder* response_decoder = nullptr; + NiceMock encoder1; + Http::ResponseDecoder* response_decoder = nullptr; EXPECT_CALL(context_.cluster_manager_.conn_pool_, newStream(_, _)) .WillOnce(Invoke( - [&](Http::StreamDecoder& decoder, + [&](Http::ResponseDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { response_decoder = &decoder; EXPECT_CALL(encoder1.stream_, connectionLocalAddress()) @@ -190,10 +190,10 @@ class RouterUpstreamLogTest : public testing::Test { per_try_timeout_->invokeCallback(); // We expect this reset to kick off a new request. - NiceMock encoder2; + NiceMock encoder2; EXPECT_CALL(context_.cluster_manager_.conn_pool_, newStream(_, _)) .WillOnce(Invoke( - [&](Http::StreamDecoder& decoder, + [&](Http::ResponseDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks) -> Http::ConnectionPool::Cancellable* { response_decoder = &decoder; EXPECT_CALL(context_.cluster_manager_.conn_pool_.host_->outlier_detector_, diff --git a/test/common/upstream/health_checker_impl_test.cc b/test/common/upstream/health_checker_impl_test.cc index 00476d1f22bc..0ea1169811e6 100644 --- a/test/common/upstream/health_checker_impl_test.cc +++ b/test/common/upstream/health_checker_impl_test.cc @@ -117,8 +117,8 @@ class HttpHealthCheckerImplTest : public testing::Test { Http::MockClientConnection* codec_{}; Stats::IsolatedStoreImpl stats_store_; Network::MockClientConnection* client_connection_{}; - NiceMock request_encoder_; - Http::StreamDecoder* stream_response_callbacks_{}; + NiceMock request_encoder_; + Http::ResponseDecoder* stream_response_callbacks_{}; }; using TestSessionPtr = std::unique_ptr; @@ -3375,8 +3375,8 @@ class GrpcHealthCheckerImplTestBase { Http::MockClientConnection* codec_{}; Stats::IsolatedStoreImpl stats_store_; Network::MockClientConnection* client_connection_{}; - NiceMock request_encoder_; - Http::StreamDecoder* stream_response_callbacks_{}; + NiceMock request_encoder_; + Http::ResponseDecoder* stream_response_callbacks_{}; CodecClientForTest* codec_client_{}; }; diff --git a/test/extensions/quic_listeners/quiche/envoy_quic_client_session_test.cc b/test/extensions/quic_listeners/quiche/envoy_quic_client_session_test.cc index 6b24baec2192..463ca86cf25e 100644 --- a/test/extensions/quic_listeners/quiche/envoy_quic_client_session_test.cc +++ b/test/extensions/quic_listeners/quiche/envoy_quic_client_session_test.cc @@ -138,7 +138,7 @@ class EnvoyQuicClientSessionTest : public testing::TestWithParam { } } - EnvoyQuicClientStream& sendGetRequest(Http::StreamDecoder& response_decoder, + EnvoyQuicClientStream& sendGetRequest(Http::ResponseDecoder& response_decoder, Http::StreamCallbacks& stream_callbacks) { auto& stream = dynamic_cast(http_connection_.newStream(response_decoder)); @@ -178,7 +178,7 @@ INSTANTIATE_TEST_SUITE_P(EnvoyQuicClientSessionTests, EnvoyQuicClientSessionTest testing::ValuesIn({true, false})); TEST_P(EnvoyQuicClientSessionTest, NewStream) { - Http::MockStreamDecoder response_decoder; + Http::MockResponseDecoder response_decoder; Http::MockStreamCallbacks stream_callbacks; EnvoyQuicClientStream& stream = sendGetRequest(response_decoder, stream_callbacks); @@ -195,7 +195,7 @@ TEST_P(EnvoyQuicClientSessionTest, NewStream) { } TEST_P(EnvoyQuicClientSessionTest, OnResetFrame) { - Http::MockStreamDecoder response_decoder; + Http::MockResponseDecoder response_decoder; Http::MockStreamCallbacks stream_callbacks; EnvoyQuicClientStream& stream = sendGetRequest(response_decoder, stream_callbacks); @@ -220,7 +220,7 @@ TEST_P(EnvoyQuicClientSessionTest, ConnectionClose) { } TEST_P(EnvoyQuicClientSessionTest, ConnectionCloseWithActiveStream) { - Http::MockStreamDecoder response_decoder; + Http::MockResponseDecoder response_decoder; Http::MockStreamCallbacks stream_callbacks; EnvoyQuicClientStream& stream = sendGetRequest(response_decoder, stream_callbacks); EXPECT_CALL(*quic_connection_, diff --git a/test/extensions/quic_listeners/quiche/envoy_quic_client_stream_test.cc b/test/extensions/quic_listeners/quiche/envoy_quic_client_stream_test.cc index 10fa5fd7f900..308147e78c07 100644 --- a/test/extensions/quic_listeners/quiche/envoy_quic_client_stream_test.cc +++ b/test/extensions/quic_listeners/quiche/envoy_quic_client_stream_test.cc @@ -42,7 +42,7 @@ class EnvoyQuicClientStreamTest : public testing::TestWithParam { stream_id_(quic_version_.transport_version == quic::QUIC_VERSION_99 ? 4u : 5u), quic_stream_(new EnvoyQuicClientStream(stream_id_, &quic_session_, quic::BIDIRECTIONAL)), request_headers_{{":authority", host_}, {":method", "POST"}, {":path", "/"}} { - quic_stream_->setDecoder(stream_decoder_); + quic_stream_->setResponseDecoder(stream_decoder_); quic_stream_->addCallbacks(stream_callbacks_); quic_session_.ActivateStream(std::unique_ptr(quic_stream_)); EXPECT_CALL(quic_session_, WritevData(_, _, _, _, _)) @@ -96,7 +96,7 @@ class EnvoyQuicClientStreamTest : public testing::TestWithParam { MockEnvoyQuicClientSession quic_session_; quic::QuicStreamId stream_id_; EnvoyQuicClientStream* quic_stream_; - Http::MockStreamDecoder stream_decoder_; + Http::MockResponseDecoder stream_decoder_; Http::MockStreamCallbacks stream_callbacks_; std::string host_{"www.abc.com"}; Http::TestHeaderMapImpl request_headers_; diff --git a/test/extensions/quic_listeners/quiche/envoy_quic_server_session_test.cc b/test/extensions/quic_listeners/quiche/envoy_quic_server_session_test.cc index 93c0e414de70..ee7e0d4414b6 100644 --- a/test/extensions/quic_listeners/quiche/envoy_quic_server_session_test.cc +++ b/test/extensions/quic_listeners/quiche/envoy_quic_server_session_test.cc @@ -155,11 +155,11 @@ class EnvoyQuicServerSessionTest : public testing::TestWithParam { return envoy_quic_session_.initializeReadFilters(); } - quic::QuicStream* createNewStream(Http::MockStreamDecoder& request_decoder, + quic::QuicStream* createNewStream(Http::MockRequestDecoder& request_decoder, Http::MockStreamCallbacks& stream_callbacks) { EXPECT_CALL(http_connection_callbacks_, newStream(_, false)) - .WillOnce(Invoke([&request_decoder, &stream_callbacks](Http::StreamEncoder& encoder, - bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&request_decoder, &stream_callbacks](Http::ResponseEncoder& encoder, + bool) -> Http::RequestDecoder& { encoder.getStream().addCallbacks(stream_callbacks); return request_decoder; })); @@ -212,7 +212,7 @@ INSTANTIATE_TEST_SUITE_P(EnvoyQuicServerSessionTests, EnvoyQuicServerSessionTest TEST_P(EnvoyQuicServerSessionTest, NewStream) { installReadFilter(); - Http::MockStreamDecoder request_decoder; + Http::MockRequestDecoder request_decoder; EXPECT_CALL(http_connection_callbacks_, newStream(_, false)) .WillOnce(testing::ReturnRef(request_decoder)); quic::QuicStreamId stream_id = @@ -241,7 +241,7 @@ TEST_P(EnvoyQuicServerSessionTest, NewStream) { TEST_P(EnvoyQuicServerSessionTest, InvalidIncomingStreamId) { quic::SetVerbosityLogThreshold(1); installReadFilter(); - Http::MockStreamDecoder request_decoder; + Http::MockRequestDecoder request_decoder; Http::MockStreamCallbacks stream_callbacks; // IETF stream 5 and G-Quic stream 2 are server initiated. quic::QuicStreamId stream_id = @@ -258,7 +258,7 @@ TEST_P(EnvoyQuicServerSessionTest, InvalidIncomingStreamId) { TEST_P(EnvoyQuicServerSessionTest, NoNewStreamForInvalidIncomingStream) { installReadFilter(); - Http::MockStreamDecoder request_decoder; + Http::MockRequestDecoder request_decoder; Http::MockStreamCallbacks stream_callbacks; // IETF stream 5 and G-Quic stream 2 are server initiated. quic::QuicStreamId stream_id = @@ -274,7 +274,7 @@ TEST_P(EnvoyQuicServerSessionTest, NoNewStreamForInvalidIncomingStream) { TEST_P(EnvoyQuicServerSessionTest, OnResetFrame) { installReadFilter(); - Http::MockStreamDecoder request_decoder; + Http::MockRequestDecoder request_decoder; Http::MockStreamCallbacks stream_callbacks; quic::QuicStream* stream1 = createNewStream(request_decoder, stream_callbacks); quic::QuicRstStreamFrame rst1(/*control_frame_id=*/1u, stream1->id(), @@ -291,8 +291,8 @@ TEST_P(EnvoyQuicServerSessionTest, OnResetFrame) { stream1->OnStreamReset(rst1); EXPECT_CALL(http_connection_callbacks_, newStream(_, false)) - .WillOnce(Invoke([&request_decoder, &stream_callbacks](Http::StreamEncoder& encoder, - bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&request_decoder, &stream_callbacks](Http::ResponseEncoder& encoder, + bool) -> Http::RequestDecoder& { encoder.getStream().addCallbacks(stream_callbacks); return request_decoder; })); @@ -321,7 +321,7 @@ TEST_P(EnvoyQuicServerSessionTest, ConnectionClose) { TEST_P(EnvoyQuicServerSessionTest, ConnectionCloseWithActiveStream) { installReadFilter(); - Http::MockStreamDecoder request_decoder; + Http::MockRequestDecoder request_decoder; Http::MockStreamCallbacks stream_callbacks; quic::QuicStream* stream = createNewStream(request_decoder, stream_callbacks); EXPECT_CALL(*quic_connection_, @@ -336,7 +336,7 @@ TEST_P(EnvoyQuicServerSessionTest, ConnectionCloseWithActiveStream) { TEST_P(EnvoyQuicServerSessionTest, NoFlushWithDataToWrite) { installReadFilter(); - Http::MockStreamDecoder request_decoder; + Http::MockRequestDecoder request_decoder; Http::MockStreamCallbacks stream_callbacks; quic::QuicStream* stream = createNewStream(request_decoder, stream_callbacks); envoy_quic_session_.MarkConnectionLevelWriteBlocked(stream->id()); @@ -353,7 +353,7 @@ TEST_P(EnvoyQuicServerSessionTest, NoFlushWithDataToWrite) { TEST_P(EnvoyQuicServerSessionTest, FlushCloseWithDataToWrite) { installReadFilter(); - Http::MockStreamDecoder request_decoder; + Http::MockRequestDecoder request_decoder; Http::MockStreamCallbacks stream_callbacks; quic::QuicStream* stream = createNewStream(request_decoder, stream_callbacks); @@ -403,7 +403,7 @@ TEST_P(EnvoyQuicServerSessionTest, WriteUpdatesDelayCloseTimer) { 10 * quic::kDefaultFlowControlSendWindow); envoy_quic_session_.setDelayedCloseTimeout(std::chrono::milliseconds(100)); - Http::MockStreamDecoder request_decoder; + Http::MockRequestDecoder request_decoder; Http::MockStreamCallbacks stream_callbacks; // Create a stream and write enough data to make it blocked. auto stream = @@ -498,7 +498,7 @@ TEST_P(EnvoyQuicServerSessionTest, FlushCloseNoTimeout) { envoy_quic_session_.flow_controller()->UpdateSendWindowOffset( 10 * quic::kDefaultFlowControlSendWindow); - Http::MockStreamDecoder request_decoder; + Http::MockRequestDecoder request_decoder; Http::MockStreamCallbacks stream_callbacks; // Create a stream and write enough data to make it blocked. auto stream = @@ -562,7 +562,7 @@ TEST_P(EnvoyQuicServerSessionTest, FlushCloseNoTimeout) { TEST_P(EnvoyQuicServerSessionTest, FlushCloseWithTimeout) { installReadFilter(); envoy_quic_session_.setDelayedCloseTimeout(std::chrono::milliseconds(100)); - Http::MockStreamDecoder request_decoder; + Http::MockRequestDecoder request_decoder; Http::MockStreamCallbacks stream_callbacks; quic::QuicStream* stream = createNewStream(request_decoder, stream_callbacks); @@ -592,7 +592,7 @@ TEST_P(EnvoyQuicServerSessionTest, FlushCloseWithTimeout) { TEST_P(EnvoyQuicServerSessionTest, FlushAndWaitForCloseWithTimeout) { installReadFilter(); envoy_quic_session_.setDelayedCloseTimeout(std::chrono::milliseconds(100)); - Http::MockStreamDecoder request_decoder; + Http::MockRequestDecoder request_decoder; Http::MockStreamCallbacks stream_callbacks; quic::QuicStream* stream = createNewStream(request_decoder, stream_callbacks); @@ -624,7 +624,7 @@ TEST_P(EnvoyQuicServerSessionTest, FlushAndWaitForCloseWithTimeout) { TEST_P(EnvoyQuicServerSessionTest, FlusWriteTransitToFlushWriteWithDelay) { installReadFilter(); envoy_quic_session_.setDelayedCloseTimeout(std::chrono::milliseconds(100)); - Http::MockStreamDecoder request_decoder; + Http::MockRequestDecoder request_decoder; Http::MockStreamCallbacks stream_callbacks; quic::QuicStream* stream = createNewStream(request_decoder, stream_callbacks); @@ -788,11 +788,11 @@ TEST_P(EnvoyQuicServerSessionTest, SendBufferWatermark) { envoy_quic_session_.flow_controller()->UpdateSendWindowOffset( 10 * quic::kDefaultFlowControlSendWindow); installReadFilter(); - Http::MockStreamDecoder request_decoder; + Http::MockRequestDecoder request_decoder; Http::MockStreamCallbacks stream_callbacks; EXPECT_CALL(http_connection_callbacks_, newStream(_, false)) - .WillOnce(Invoke([&request_decoder, &stream_callbacks](Http::StreamEncoder& encoder, - bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&request_decoder, &stream_callbacks](Http::ResponseEncoder& encoder, + bool) -> Http::RequestDecoder& { encoder.getStream().addCallbacks(stream_callbacks); return request_decoder; })); @@ -833,11 +833,11 @@ TEST_P(EnvoyQuicServerSessionTest, SendBufferWatermark) { // Receive another request and send back response to trigger connection level // send buffer watermark. - Http::MockStreamDecoder request_decoder2; + Http::MockRequestDecoder request_decoder2; Http::MockStreamCallbacks stream_callbacks2; EXPECT_CALL(http_connection_callbacks_, newStream(_, false)) - .WillOnce(Invoke([&request_decoder2, &stream_callbacks2](Http::StreamEncoder& encoder, - bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&request_decoder2, &stream_callbacks2](Http::ResponseEncoder& encoder, + bool) -> Http::RequestDecoder& { encoder.getStream().addCallbacks(stream_callbacks2); return request_decoder2; })); @@ -864,11 +864,11 @@ TEST_P(EnvoyQuicServerSessionTest, SendBufferWatermark) { // Receive another request, the new stream should be notified about connection // high watermark reached upon creation. - Http::MockStreamDecoder request_decoder3; + Http::MockRequestDecoder request_decoder3; Http::MockStreamCallbacks stream_callbacks3; EXPECT_CALL(http_connection_callbacks_, newStream(_, false)) - .WillOnce(Invoke([&request_decoder3, &stream_callbacks3](Http::StreamEncoder& encoder, - bool) -> Http::StreamDecoder& { + .WillOnce(Invoke([&request_decoder3, &stream_callbacks3](Http::ResponseEncoder& encoder, + bool) -> Http::RequestDecoder& { encoder.getStream().addCallbacks(stream_callbacks3); return request_decoder3; })); diff --git a/test/extensions/quic_listeners/quiche/envoy_quic_server_stream_test.cc b/test/extensions/quic_listeners/quiche/envoy_quic_server_stream_test.cc index cc5e252ef62a..46eeefa6b548 100644 --- a/test/extensions/quic_listeners/quiche/envoy_quic_server_stream_test.cc +++ b/test/extensions/quic_listeners/quiche/envoy_quic_server_stream_test.cc @@ -47,7 +47,7 @@ class EnvoyQuicServerStreamTest : public testing::TestWithParam { stream_id_(VersionUsesHttp3(quic_version_.transport_version) ? 4u : 5u), quic_stream_(new EnvoyQuicServerStream(stream_id_, &quic_session_, quic::BIDIRECTIONAL)), response_headers_{{":status", "200"}} { - quic_stream_->setDecoder(stream_decoder_); + quic_stream_->setRequestDecoder(stream_decoder_); quic_stream_->addCallbacks(stream_callbacks_); quic_session_.ActivateStream(std::unique_ptr(quic_stream_)); EXPECT_CALL(quic_session_, WritevData(_, _, _, _, _)) @@ -138,7 +138,7 @@ class EnvoyQuicServerStreamTest : public testing::TestWithParam { MockEnvoyQuicSession quic_session_; quic::QuicStreamId stream_id_; EnvoyQuicServerStream* quic_stream_; - Http::MockStreamDecoder stream_decoder_; + Http::MockRequestDecoder stream_decoder_; Http::MockStreamCallbacks stream_callbacks_; quic::QuicHeaderList request_headers_; Http::TestHeaderMapImpl response_headers_; diff --git a/test/integration/api_listener_integration_test.cc b/test/integration/api_listener_integration_test.cc index 7328d87ea3b9..ee1e2d672dab 100644 --- a/test/integration/api_listener_integration_test.cc +++ b/test/integration/api_listener_integration_test.cc @@ -74,7 +74,7 @@ name: api_listener )EOF"; } - NiceMock stream_encoder_; + NiceMock stream_encoder_; }; ACTION_P(Notify, notification) { notification->Notify(); } diff --git a/test/integration/autonomous_upstream.cc b/test/integration/autonomous_upstream.cc index c96cb8d23e52..28abf3d2bff5 100644 --- a/test/integration/autonomous_upstream.cc +++ b/test/integration/autonomous_upstream.cc @@ -20,7 +20,7 @@ const char AutonomousStream::RESPONSE_SIZE_BYTES[] = "response_size_bytes"; const char AutonomousStream::EXPECT_REQUEST_SIZE_BYTES[] = "expect_request_size_bytes"; const char AutonomousStream::RESET_AFTER_REQUEST[] = "reset_after_request"; -AutonomousStream::AutonomousStream(FakeHttpConnection& parent, Http::StreamEncoder& encoder, +AutonomousStream::AutonomousStream(FakeHttpConnection& parent, Http::ResponseEncoder& encoder, AutonomousUpstream& upstream, bool allow_incomplete_streams) : FakeStream(parent, encoder, upstream.timeSystem()), upstream_(upstream), allow_incomplete_streams_(allow_incomplete_streams) {} @@ -69,8 +69,8 @@ AutonomousHttpConnection::AutonomousHttpConnection(SharedConnectionWrapper& shar Http::DEFAULT_MAX_REQUEST_HEADERS_KB, Http::DEFAULT_MAX_HEADERS_COUNT), upstream_(upstream) {} -Http::StreamDecoder& AutonomousHttpConnection::newStream(Http::StreamEncoder& response_encoder, - bool) { +Http::RequestDecoder& AutonomousHttpConnection::newStream(Http::ResponseEncoder& response_encoder, + bool) { auto stream = new AutonomousStream(*this, response_encoder, upstream_, upstream_.allow_incomplete_streams_); streams_.push_back(FakeStreamPtr{stream}); diff --git a/test/integration/autonomous_upstream.h b/test/integration/autonomous_upstream.h index 89161dab65e3..92d50c11b061 100644 --- a/test/integration/autonomous_upstream.h +++ b/test/integration/autonomous_upstream.h @@ -20,7 +20,7 @@ class AutonomousStream : public FakeStream { // sending a response. static const char RESET_AFTER_REQUEST[]; - AutonomousStream(FakeHttpConnection& parent, Http::StreamEncoder& encoder, + AutonomousStream(FakeHttpConnection& parent, Http::ResponseEncoder& encoder, AutonomousUpstream& upstream, bool allow_incomplete_streams); ~AutonomousStream() override; @@ -38,7 +38,7 @@ class AutonomousHttpConnection : public FakeHttpConnection { AutonomousHttpConnection(SharedConnectionWrapper& shared_connection, Stats::Store& store, Type type, AutonomousUpstream& upstream); - Http::StreamDecoder& newStream(Http::StreamEncoder& response_encoder, bool) override; + Http::RequestDecoder& newStream(Http::ResponseEncoder& response_encoder, bool) override; private: AutonomousUpstream& upstream_; diff --git a/test/integration/fake_upstream.cc b/test/integration/fake_upstream.cc index 1a2b7c680771..f9f6d7fb3ba4 100644 --- a/test/integration/fake_upstream.cc +++ b/test/integration/fake_upstream.cc @@ -38,7 +38,7 @@ using testing::AssertionResult; using testing::AssertionSuccess; namespace Envoy { -FakeStream::FakeStream(FakeHttpConnection& parent, Http::StreamEncoder& encoder, +FakeStream::FakeStream(FakeHttpConnection& parent, Http::ResponseEncoder& encoder, Event::TestTimeSystem& time_system) : parent_(parent), encoder_(encoder), time_system_(time_system) { encoder.getStream().addCallbacks(*this); @@ -261,7 +261,7 @@ AssertionResult FakeConnectionBase::enableHalfClose(bool enable, [enable](Network::Connection& connection) { connection.enableHalfClose(enable); }, timeout); } -Http::StreamDecoder& FakeHttpConnection::newStream(Http::StreamEncoder& encoder, bool) { +Http::RequestDecoder& FakeHttpConnection::newStream(Http::ResponseEncoder& encoder, bool) { Thread::LockGuard lock(lock_); new_streams_.emplace_back(new FakeStream(*this, encoder, time_system_)); connection_event_.notifyOne(); diff --git a/test/integration/fake_upstream.h b/test/integration/fake_upstream.h index c478bcbd377d..47de477a7b7a 100644 --- a/test/integration/fake_upstream.h +++ b/test/integration/fake_upstream.h @@ -43,11 +43,11 @@ class FakeHttpConnection; /** * Provides a fake HTTP stream for integration testing. */ -class FakeStream : public Http::StreamDecoder, +class FakeStream : public Http::RequestDecoder, public Http::StreamCallbacks, Logger::Loggable { public: - FakeStream(FakeHttpConnection& parent, Http::StreamEncoder& encoder, + FakeStream(FakeHttpConnection& parent, Http::ResponseEncoder& encoder, Event::TestTimeSystem& time_system); uint64_t bodyLength() { return body_.length(); } @@ -152,12 +152,13 @@ class FakeStream : public Http::StreamDecoder, } // Http::StreamDecoder - void decode100ContinueHeaders(Http::HeaderMapPtr&&) override {} - void decodeHeaders(Http::HeaderMapPtr&& headers, bool end_stream) override; void decodeData(Buffer::Instance& data, bool end_stream) override; - void decodeTrailers(Http::HeaderMapPtr&& trailers) override; void decodeMetadata(Http::MetadataMapPtr&& metadata_map_ptr) override; + // Http::RequestDecoder + void decodeHeaders(Http::HeaderMapPtr&& headers, bool end_stream) override; + void decodeTrailers(Http::HeaderMapPtr&& trailers) override; + // Http::StreamCallbacks void onResetStream(Http::StreamResetReason reason, absl::string_view transport_failure_reason) override; @@ -178,7 +179,7 @@ class FakeStream : public Http::StreamDecoder, private: FakeHttpConnection& parent_; - Http::StreamEncoder& encoder_; + Http::ResponseEncoder& encoder_; Thread::MutexBasicLockable lock_; Thread::CondVar decoder_event_; Http::HeaderMapPtr trailers_; @@ -430,7 +431,7 @@ class FakeHttpConnection : public Http::ServerConnectionCallbacks, public FakeCo std::chrono::milliseconds timeout = TestUtility::DefaultTimeout); // Http::ServerConnectionCallbacks - Http::StreamDecoder& newStream(Http::StreamEncoder& response_encoder, bool) override; + Http::RequestDecoder& newStream(Http::ResponseEncoder& response_encoder, bool) override; void onGoAway() override { NOT_IMPLEMENTED_GCOVR_EXCL_LINE; } private: diff --git a/test/integration/http2_integration_test.cc b/test/integration/http2_integration_test.cc index c7d2548ad903..41065388093e 100644 --- a/test/integration/http2_integration_test.cc +++ b/test/integration/http2_integration_test.cc @@ -884,8 +884,8 @@ TEST_P(Http2IntegrationTest, GrpcRequestTimeout) { TEST_P(Http2IntegrationTest, IdleTimeoutWithSimultaneousRequests) { FakeHttpConnectionPtr fake_upstream_connection1; FakeHttpConnectionPtr fake_upstream_connection2; - Http::StreamEncoder* encoder1; - Http::StreamEncoder* encoder2; + Http::RequestEncoder* encoder1; + Http::RequestEncoder* encoder2; FakeStreamPtr upstream_request1; FakeStreamPtr upstream_request2; int32_t request1_bytes = 1024; @@ -1018,8 +1018,8 @@ TEST_P(Http2IntegrationTest, RequestMirrorWithBody) { void Http2IntegrationTest::simultaneousRequest(int32_t request1_bytes, int32_t request2_bytes) { FakeHttpConnectionPtr fake_upstream_connection1; FakeHttpConnectionPtr fake_upstream_connection2; - Http::StreamEncoder* encoder1; - Http::StreamEncoder* encoder2; + Http::RequestEncoder* encoder1; + Http::RequestEncoder* encoder2; FakeStreamPtr upstream_request1; FakeStreamPtr upstream_request2; initialize(); @@ -1249,7 +1249,7 @@ void Http2RingHashIntegrationTest::sendMultipleRequests( std::function cb) { TestRandomGenerator rand; const uint32_t num_requests = 50; - std::vector encoders; + std::vector encoders; std::vector responses; std::vector upstream_requests; diff --git a/test/integration/http2_upstream_integration_test.cc b/test/integration/http2_upstream_integration_test.cc index 989c593331dc..418ad053be1d 100644 --- a/test/integration/http2_upstream_integration_test.cc +++ b/test/integration/http2_upstream_integration_test.cc @@ -148,7 +148,7 @@ void Http2UpstreamIntegrationTest::simultaneousRequest(uint32_t request1_bytes, {":path", "/test/long/url"}, {":scheme", "http"}, {":authority", "host"}}); - Http::StreamEncoder* encoder1 = &encoder_decoder1.first; + Http::RequestEncoder* encoder1 = &encoder_decoder1.first; auto response1 = std::move(encoder_decoder1.second); ASSERT_TRUE(fake_upstreams_[0]->waitForHttpConnection(*dispatcher_, fake_upstream_connection_)); ASSERT_TRUE(fake_upstream_connection_->waitForNewStream(*dispatcher_, upstream_request1)); @@ -159,7 +159,7 @@ void Http2UpstreamIntegrationTest::simultaneousRequest(uint32_t request1_bytes, {":path", "/test/long/url"}, {":scheme", "http"}, {":authority", "host"}}); - Http::StreamEncoder* encoder2 = &encoder_decoder2.first; + Http::RequestEncoder* encoder2 = &encoder_decoder2.first; auto response2 = std::move(encoder_decoder2.second); ASSERT_TRUE(fake_upstream_connection_->waitForNewStream(*dispatcher_, upstream_request2)); @@ -204,7 +204,7 @@ TEST_P(Http2UpstreamIntegrationTest, LargeSimultaneousRequestWithBufferLimits) { void Http2UpstreamIntegrationTest::manySimultaneousRequests(uint32_t request_bytes, uint32_t) { TestRandomGenerator rand; const uint32_t num_requests = 50; - std::vector encoders; + std::vector encoders; std::vector responses; std::vector response_bytes; autonomous_upstream_ = true; @@ -264,7 +264,7 @@ TEST_P(Http2UpstreamIntegrationTest, ManyLargeSimultaneousRequestWithRandomBacku TEST_P(Http2UpstreamIntegrationTest, UpstreamConnectionCloseWithManyStreams) { config_helper_.setBufferLimits(1024, 1024); // Set buffer limits upstream and downstream. const uint32_t num_requests = 20; - std::vector encoders; + std::vector encoders; std::vector responses; std::vector upstream_requests; initialize(); diff --git a/test/integration/http_integration.cc b/test/integration/http_integration.cc index b827486643a3..0ed456876752 100644 --- a/test/integration/http_integration.cc +++ b/test/integration/http_integration.cc @@ -77,7 +77,7 @@ void IntegrationCodecClient::flushWrite() { IntegrationStreamDecoderPtr IntegrationCodecClient::makeHeaderOnlyRequest(const Http::HeaderMap& headers) { auto response = std::make_unique(dispatcher_); - Http::StreamEncoder& encoder = newStream(*response); + Http::RequestEncoder& encoder = newStream(*response); encoder.getStream().addCallbacks(*response); encoder.encodeHeaders(headers, true); flushWrite(); @@ -93,7 +93,7 @@ IntegrationStreamDecoderPtr IntegrationCodecClient::makeRequestWithBody(const Http::HeaderMap& headers, const std::string& body) { auto response = std::make_unique(dispatcher_); - Http::StreamEncoder& encoder = newStream(*response); + Http::RequestEncoder& encoder = newStream(*response); encoder.getStream().addCallbacks(*response); encoder.encodeHeaders(headers, false); Buffer::OwnedImpl data(body); @@ -102,37 +102,37 @@ IntegrationCodecClient::makeRequestWithBody(const Http::HeaderMap& headers, return response; } -void IntegrationCodecClient::sendData(Http::StreamEncoder& encoder, absl::string_view data, +void IntegrationCodecClient::sendData(Http::RequestEncoder& encoder, absl::string_view data, bool end_stream) { Buffer::OwnedImpl buffer_data(data.data(), data.size()); encoder.encodeData(buffer_data, end_stream); flushWrite(); } -void IntegrationCodecClient::sendData(Http::StreamEncoder& encoder, Buffer::Instance& data, +void IntegrationCodecClient::sendData(Http::RequestEncoder& encoder, Buffer::Instance& data, bool end_stream) { encoder.encodeData(data, end_stream); flushWrite(); } -void IntegrationCodecClient::sendData(Http::StreamEncoder& encoder, uint64_t size, +void IntegrationCodecClient::sendData(Http::RequestEncoder& encoder, uint64_t size, bool end_stream) { Buffer::OwnedImpl data(std::string(size, 'a')); sendData(encoder, data, end_stream); } -void IntegrationCodecClient::sendTrailers(Http::StreamEncoder& encoder, +void IntegrationCodecClient::sendTrailers(Http::RequestEncoder& encoder, const Http::HeaderMap& trailers) { encoder.encodeTrailers(trailers); flushWrite(); } -void IntegrationCodecClient::sendReset(Http::StreamEncoder& encoder) { +void IntegrationCodecClient::sendReset(Http::RequestEncoder& encoder) { encoder.getStream().resetStream(Http::StreamResetReason::LocalReset); flushWrite(); } -void IntegrationCodecClient::sendMetadata(Http::StreamEncoder& encoder, +void IntegrationCodecClient::sendMetadata(Http::RequestEncoder& encoder, Http::MetadataMap metadata_map) { Http::MetadataMapPtr metadata_map_ptr = std::make_unique(metadata_map); Http::MetadataMapVector metadata_map_vector; @@ -141,10 +141,10 @@ void IntegrationCodecClient::sendMetadata(Http::StreamEncoder& encoder, flushWrite(); } -std::pair +std::pair IntegrationCodecClient::startRequest(const Http::HeaderMap& headers) { auto response = std::make_unique(dispatcher_); - Http::StreamEncoder& encoder = newStream(*response); + Http::RequestEncoder& encoder = newStream(*response); encoder.getStream().addCallbacks(*response); encoder.encodeHeaders(headers, false); flushWrite(); diff --git a/test/integration/http_integration.h b/test/integration/http_integration.h index 16fe8192d5f9..26f56b12a86d 100644 --- a/test/integration/http_integration.h +++ b/test/integration/http_integration.h @@ -29,14 +29,14 @@ class IntegrationCodecClient : public Http::CodecClientProd { const std::string& body); bool sawGoAway() const { return saw_goaway_; } bool connected() const { return connected_; } - void sendData(Http::StreamEncoder& encoder, absl::string_view data, bool end_stream); - void sendData(Http::StreamEncoder& encoder, Buffer::Instance& data, bool end_stream); - void sendData(Http::StreamEncoder& encoder, uint64_t size, bool end_stream); - void sendTrailers(Http::StreamEncoder& encoder, const Http::HeaderMap& trailers); - void sendReset(Http::StreamEncoder& encoder); + void sendData(Http::RequestEncoder& encoder, absl::string_view data, bool end_stream); + void sendData(Http::RequestEncoder& encoder, Buffer::Instance& data, bool end_stream); + void sendData(Http::RequestEncoder& encoder, uint64_t size, bool end_stream); + void sendTrailers(Http::RequestEncoder& encoder, const Http::HeaderMap& trailers); + void sendReset(Http::RequestEncoder& encoder); // Intentionally makes a copy of metadata_map. - void sendMetadata(Http::StreamEncoder& encoder, Http::MetadataMap metadata_map); - std::pair + void sendMetadata(Http::RequestEncoder& encoder, Http::MetadataMap metadata_map); + std::pair startRequest(const Http::HeaderMap& headers); bool waitForDisconnect(std::chrono::milliseconds time_to_wait = std::chrono::milliseconds(0)); Network::ClientConnection* connection() const { return connection_.get(); } @@ -231,7 +231,7 @@ class HttpIntegrationTest : public BaseIntegrationTest { // A placeholder for the first request received at upstream. FakeStreamPtr upstream_request_; // A pointer to the request encoder, if used. - Http::StreamEncoder* request_encoder_{nullptr}; + Http::RequestEncoder* request_encoder_{nullptr}; // The response headers sent by sendRequestAndWaitForResponse() by default. Http::TestHeaderMapImpl default_response_headers_{{":status", "200"}}; Http::TestHeaderMapImpl default_request_headers_{ diff --git a/test/integration/http_timeout_integration_test.cc b/test/integration/http_timeout_integration_test.cc index 097c085eb114..6a9ae16ee2a3 100644 --- a/test/integration/http_timeout_integration_test.cc +++ b/test/integration/http_timeout_integration_test.cc @@ -185,9 +185,7 @@ TEST_P(HttpTimeoutIntegrationTest, GlobalTimeoutAfterHeadersBeforeBodyResetsUpst {":authority", "host"}, {"x-forwarded-for", "10.0.0.1"}, {"x-envoy-upstream-rq-timeout-ms", "100"}}; - std::pair encoder_decoder = - codec_client_->startRequest(request_headers); - + auto encoder_decoder = codec_client_->startRequest(request_headers); auto response = std::move(encoder_decoder.second); request_encoder_ = &encoder_decoder.first; diff --git a/test/integration/integration.h b/test/integration/integration.h index 0a04837db44f..6ba287a016d7 100644 --- a/test/integration/integration.h +++ b/test/integration/integration.h @@ -33,7 +33,7 @@ namespace Envoy { /** * Stream decoder wrapper used during integration testing. */ -class IntegrationStreamDecoder : public Http::StreamDecoder, public Http::StreamCallbacks { +class IntegrationStreamDecoder : public Http::ResponseDecoder, public Http::StreamCallbacks { public: IntegrationStreamDecoder(Event::Dispatcher& dispatcher); diff --git a/test/integration/utility.cc b/test/integration/utility.cc index ca1f05955b02..832154d754cf 100644 --- a/test/integration/utility.cc +++ b/test/integration/utility.cc @@ -81,7 +81,7 @@ IntegrationUtil::makeSingleRequest(const Network::Address::InstanceConstSharedPt client.close(); dispatcher->exit(); })); - Http::StreamEncoder& encoder = client.newStream(*response); + Http::RequestEncoder& encoder = client.newStream(*response); encoder.getStream().addCallbacks(*response); Http::HeaderMapImpl headers; diff --git a/test/integration/utility.h b/test/integration/utility.h index 6554234ddc95..93eb3459ac33 100644 --- a/test/integration/utility.h +++ b/test/integration/utility.h @@ -22,7 +22,7 @@ namespace Envoy { /** * A buffering response decoder used for testing. */ -class BufferingStreamDecoder : public Http::StreamDecoder, public Http::StreamCallbacks { +class BufferingStreamDecoder : public Http::ResponseDecoder, public Http::StreamCallbacks { public: BufferingStreamDecoder(std::function on_complete_cb) : on_complete_cb_(on_complete_cb) {} diff --git a/test/mocks/http/api_listener.h b/test/mocks/http/api_listener.h index 0032f1c71ce5..4ee7ed6cb248 100644 --- a/test/mocks/http/api_listener.h +++ b/test/mocks/http/api_listener.h @@ -12,8 +12,8 @@ class MockApiListener : public ApiListener { ~MockApiListener() override; // Http::ApiListener - MOCK_METHOD(StreamDecoder&, newStream, - (StreamEncoder & response_encoder, bool is_internally_created)); + MOCK_METHOD(RequestDecoder&, newStream, + (ResponseEncoder & response_encoder, bool is_internally_created)); }; } // namespace Http diff --git a/test/mocks/http/conn_pool.h b/test/mocks/http/conn_pool.h index dbae9603048b..f5116ae3cda6 100644 --- a/test/mocks/http/conn_pool.h +++ b/test/mocks/http/conn_pool.h @@ -8,10 +8,9 @@ namespace Envoy { namespace Http { - namespace ConnectionPool { -class MockCancellable : public Cancellable { +class MockCancellable : public Cancellable { public: MockCancellable(); ~MockCancellable() override; @@ -30,8 +29,7 @@ class MockInstance : public Instance { MOCK_METHOD(void, addDrainedCallback, (DrainedCb cb)); MOCK_METHOD(void, drainConnections, ()); MOCK_METHOD(bool, hasActiveConnections, (), (const)); - MOCK_METHOD(Cancellable*, newStream, - (Http::StreamDecoder & response_decoder, Http::ConnectionPool::Callbacks& callbacks)); + MOCK_METHOD(Cancellable*, newStream, (ResponseDecoder & response_decoder, Callbacks& callbacks)); MOCK_METHOD(Upstream::HostDescriptionConstSharedPtr, host, (), (const)); std::shared_ptr> host_; diff --git a/test/mocks/http/mocks.h b/test/mocks/http/mocks.h index bca811c617e9..b912df6c0f65 100644 --- a/test/mocks/http/mocks.h +++ b/test/mocks/http/mocks.h @@ -54,8 +54,8 @@ class MockServerConnectionCallbacks : public ServerConnectionCallbacks, ~MockServerConnectionCallbacks() override; // Http::ServerConnectionCallbacks - MOCK_METHOD(StreamDecoder&, newStream, - (StreamEncoder & response_encoder, bool is_internally_created)); + MOCK_METHOD(RequestDecoder&, newStream, + (ResponseEncoder & response_encoder, bool is_internally_created)); }; class MockStreamCallbacks : public StreamCallbacks { @@ -101,7 +101,7 @@ class MockClientConnection : public ClientConnection { MOCK_METHOD(void, onUnderlyingConnectionBelowWriteBufferLowWatermark, ()); // Http::ClientConnection - MOCK_METHOD(StreamEncoder&, newStream, (StreamDecoder & response_decoder)); + MOCK_METHOD(RequestEncoder&, newStream, (ResponseDecoder & response_decoder)); }; class MockFilterChainFactory : public FilterChainFactory { diff --git a/test/mocks/http/stream_decoder.cc b/test/mocks/http/stream_decoder.cc index 3c2c75aed33b..eec3f6abbde9 100644 --- a/test/mocks/http/stream_decoder.cc +++ b/test/mocks/http/stream_decoder.cc @@ -1,10 +1,39 @@ #include "test/mocks/http/stream_decoder.h" +using testing::_; +using testing::Invoke; + namespace Envoy { namespace Http { MockStreamDecoder::MockStreamDecoder() = default; MockStreamDecoder::~MockStreamDecoder() = default; +MockRequestDecoder::MockRequestDecoder() { + ON_CALL(*this, decodeHeaders_(_, _)).WillByDefault(Invoke([](HeaderMapPtr& headers, bool) { + // Check for passing response headers as request headers in a test. + // TODO(mattklein123): In future changes this will become impossible once the header/trailer + // implementation classes are split. + ASSERT(headers->Status() == nullptr); + // Check to see that method is not-null. Path can be null for CONNECT and authority can be null + // at the codec level. + ASSERT(headers->Method() != nullptr); + })); +} +MockRequestDecoder::~MockRequestDecoder() = default; + +MockResponseDecoder::MockResponseDecoder() { + ON_CALL(*this, decodeHeaders_(_, _)).WillByDefault(Invoke([](HeaderMapPtr& headers, bool) { + // Check for passing request headers as response headers in a test. + // TODO(mattklein123): In future changes this will become impossible once the header/trailer + // implementation classes are split. + ASSERT(headers->Status() != nullptr); + ASSERT(headers->Path() == nullptr); + ASSERT(headers->Method() == nullptr); + ASSERT(headers->Host() == nullptr); + })); +} +MockResponseDecoder::~MockResponseDecoder() = default; + } // namespace Http } // namespace Envoy diff --git a/test/mocks/http/stream_decoder.h b/test/mocks/http/stream_decoder.h index 4526fa2272af..af18cb666da7 100644 --- a/test/mocks/http/stream_decoder.h +++ b/test/mocks/http/stream_decoder.h @@ -6,11 +6,38 @@ namespace Envoy { namespace Http { -class MockStreamDecoder : public StreamDecoder { +class MockStreamDecoder : public virtual StreamDecoder { public: MockStreamDecoder(); ~MockStreamDecoder() override; + void decodeMetadata(MetadataMapPtr&& metadata_map) override { decodeMetadata_(metadata_map); } + + // Http::StreamDecoder + MOCK_METHOD(void, decodeData, (Buffer::Instance & data, bool end_stream)); + MOCK_METHOD(void, decodeMetadata_, (MetadataMapPtr & metadata_map)); +}; + +class MockRequestDecoder : public MockStreamDecoder, public RequestDecoder { +public: + MockRequestDecoder(); + ~MockRequestDecoder(); + + void decodeHeaders(HeaderMapPtr&& headers, bool end_stream) override { + decodeHeaders_(headers, end_stream); + } + void decodeTrailers(HeaderMapPtr&& trailers) override { decodeTrailers_(trailers); } + + // Http::RequestDecoder + MOCK_METHOD(void, decodeHeaders_, (HeaderMapPtr & headers, bool end_stream)); + MOCK_METHOD(void, decodeTrailers_, (HeaderMapPtr & trailers)); +}; + +class MockResponseDecoder : public MockStreamDecoder, public ResponseDecoder { +public: + MockResponseDecoder(); + ~MockResponseDecoder(); + void decode100ContinueHeaders(HeaderMapPtr&& headers) override { decode100ContinueHeaders_(headers); } @@ -19,14 +46,10 @@ class MockStreamDecoder : public StreamDecoder { } void decodeTrailers(HeaderMapPtr&& trailers) override { decodeTrailers_(trailers); } - void decodeMetadata(MetadataMapPtr&& metadata_map) override { decodeMetadata_(metadata_map); } - - // Http::StreamDecoder - MOCK_METHOD(void, decodeHeaders_, (HeaderMapPtr & headers, bool end_stream)); + // Http::ResponseDecoder MOCK_METHOD(void, decode100ContinueHeaders_, (HeaderMapPtr & headers)); - MOCK_METHOD(void, decodeData, (Buffer::Instance & data, bool end_stream)); + MOCK_METHOD(void, decodeHeaders_, (HeaderMapPtr & headers, bool end_stream)); MOCK_METHOD(void, decodeTrailers_, (HeaderMapPtr & trailers)); - MOCK_METHOD(void, decodeMetadata_, (MetadataMapPtr & metadata_map)); }; } // namespace Http diff --git a/test/mocks/http/stream_encoder.cc b/test/mocks/http/stream_encoder.cc index 98fdec782184..d0da12b71b97 100644 --- a/test/mocks/http/stream_encoder.cc +++ b/test/mocks/http/stream_encoder.cc @@ -1,5 +1,8 @@ #include "test/mocks/http/stream_encoder.h" +using testing::_; +using testing::Invoke; + namespace Envoy { namespace Http { @@ -9,5 +12,31 @@ MockStreamEncoder::MockStreamEncoder() { MockStreamEncoder::~MockStreamEncoder() = default; +MockRequestEncoder::MockRequestEncoder() { + ON_CALL(*this, encodeHeaders(_, _)).WillByDefault(Invoke([](const HeaderMap& headers, bool) { + // Check for passing response headers as request headers in a test. + // TODO(mattklein123): In future changes this will become impossible once the header/trailer + // implementation classes are split. + ASSERT(headers.Status() == nullptr); + // Check to see that method is not-null. Path can be null for CONNECT and authority can be null + // at the codec level. + ASSERT(headers.Method() != nullptr); + })); +} +MockRequestEncoder::~MockRequestEncoder() = default; + +MockResponseEncoder::MockResponseEncoder() { + ON_CALL(*this, encodeHeaders(_, _)).WillByDefault(Invoke([](const HeaderMap& headers, bool) { + // Check for passing request headers as response headers in a test. + // TODO(mattklein123): In future changes this will become impossible once the header/trailer + // implementation classes are split. + ASSERT(headers.Status() != nullptr); + ASSERT(headers.Path() == nullptr); + ASSERT(headers.Method() == nullptr); + ASSERT(headers.Host() == nullptr); + })); +} +MockResponseEncoder::~MockResponseEncoder() = default; + } // namespace Http } // namespace Envoy diff --git a/test/mocks/http/stream_encoder.h b/test/mocks/http/stream_encoder.h index a55aed27e0a1..2adb8d484b1f 100644 --- a/test/mocks/http/stream_encoder.h +++ b/test/mocks/http/stream_encoder.h @@ -9,21 +9,39 @@ namespace Envoy { namespace Http { -class MockStreamEncoder : public StreamEncoder { +class MockStreamEncoder : public virtual StreamEncoder { public: MockStreamEncoder(); ~MockStreamEncoder() override; // Http::StreamEncoder - MOCK_METHOD(void, encode100ContinueHeaders, (const HeaderMap& headers)); - MOCK_METHOD(void, encodeHeaders, (const HeaderMap& headers, bool end_stream)); MOCK_METHOD(void, encodeData, (Buffer::Instance & data, bool end_stream)); - MOCK_METHOD(void, encodeTrailers, (const HeaderMap& trailers)); MOCK_METHOD(void, encodeMetadata, (const MetadataMapVector& metadata_map_vector)); MOCK_METHOD(Stream&, getStream, ()); testing::NiceMock stream_; }; +class MockRequestEncoder : public MockStreamEncoder, public RequestEncoder { +public: + MockRequestEncoder(); + ~MockRequestEncoder(); + + // Http::RequestEncoder + MOCK_METHOD(void, encodeHeaders, (const HeaderMap& headers, bool end_stream)); + MOCK_METHOD(void, encodeTrailers, (const HeaderMap& trailers)); +}; + +class MockResponseEncoder : public MockStreamEncoder, public ResponseEncoder { +public: + MockResponseEncoder(); + ~MockResponseEncoder(); + + // Http::ResponseEncoder + MOCK_METHOD(void, encode100ContinueHeaders, (const HeaderMap& headers)); + MOCK_METHOD(void, encodeHeaders, (const HeaderMap& headers, bool end_stream)); + MOCK_METHOD(void, encodeTrailers, (const HeaderMap& trailers)); +}; + } // namespace Http } // namespace Envoy