Adding http client support for ext_proc filter (envoyproxy#35676)

Risk Level: low
Testing: n/a
Docs Changes: n/a
Release Notes: inline
Fixes:

Description:
This is to address the 2st step of
envoyproxy#35488, i.e, the ext_proc HTTP
client framework.

---------

Signed-off-by: Yanjun Xiang <yanjunxiang@google.com>

source/extensions/filters/http/ext_proc/http_client/BUILD

@@ -0,0 +1,29 @@
+load(
+    "//bazel:envoy_build_system.bzl",
+    "envoy_cc_library",
+    "envoy_extension_package",
+)
+
+licenses(["notice"])  # Apache 2
+
+envoy_extension_package()
+
+envoy_cc_library(
+    name = "client_base_interface",
+    hdrs = ["client_base.h"],
+    tags = ["skip_on_windows"],
+    deps = [],
+)
+
+envoy_cc_library(
+    name = "http_client_lib",
+    srcs = ["http_client_impl.cc"],
+    hdrs = ["http_client_impl.h"],
+    tags = ["skip_on_windows"],
+    deps = [
+        "client_base_interface",
+        "//source/common/common:enum_to_int",
+        "//source/common/http:utility_lib",
+        "//source/extensions/filters/http/ext_proc",
+    ],
+)

source/extensions/filters/http/ext_proc/http_client/client_base.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <memory>
+
+namespace Envoy {
+namespace Extensions {
+namespace HttpFilters {
+namespace ExternalProcessing {
+
+/**
+ * Async callbacks used during external processing.
+ */
+class RequestCallbacks {
+public:
+  virtual ~RequestCallbacks() = default;
+  virtual void onComplete() PURE;
+};
+
+/**
+ * Async client base class used during external processing.
+ */
+class ClientBase {
+public:
+  virtual ~ClientBase() = default;
+
+  virtual void sendRequest() PURE;
+  virtual void cancel() PURE;
+};
+
+} // namespace ExternalProcessing
+} // namespace HttpFilters
+} // namespace Extensions
+} // namespace Envoy

source/extensions/filters/http/ext_proc/http_client/http_client_impl.cc

@@ -0,0 +1,45 @@
+#include "source/extensions/filters/http/ext_proc/http_client/http_client_impl.h"
+
+#include "source/common/common/enum_to_int.h"
+#include "source/common/http/utility.h"
+
+namespace Envoy {
+namespace Extensions {
+namespace HttpFilters {
+namespace ExternalProcessing {
+
+void ExtProcHttpClient::onSuccess(const Http::AsyncClient::Request&,
+                                  Http::ResponseMessagePtr&& response) {
+  auto status = Envoy::Http::Utility::getResponseStatusOrNullopt(response->headers());
+  if (status.has_value()) {
+    uint64_t status_code = status.value();
+    if (status_code == Envoy::enumToInt(Envoy::Http::Code::OK)) {
+      ENVOY_LOG(error, "Response status is OK");
+    } else {
+      ENVOY_LOG(error, "Response status is not OK, status: {}", status_code);
+      onError();
+    }
+  } else {
+    // This occurs if the response headers are invalid.
+    ENVOY_LOG(error, "Failed to get the response because response headers are not valid.");
+    onError();
+  }
+}
+
+void ExtProcHttpClient::onFailure(const Http::AsyncClient::Request&,
+                                  Http::AsyncClient::FailureReason reason) {
+  ASSERT(reason == Http::AsyncClient::FailureReason::Reset ||
+         reason == Http::AsyncClient::FailureReason::ExceedResponseBufferLimit);
+  ENVOY_LOG(error, "Request failed: stream has been reset");
+  onError();
+}
+
+void ExtProcHttpClient::onError() {
+  // Cancel if the request is active.
+  cancel();
+}
+
+} // namespace ExternalProcessing
+} // namespace HttpFilters
+} // namespace Extensions
+} // namespace Envoy

source/extensions/filters/http/ext_proc/http_client/http_client_impl.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <memory>
+
+#include "envoy/http/async_client.h"
+
+#include "source/common/common/logger.h"
+#include "source/extensions/filters/http/ext_proc/ext_proc.h"
+#include "source/extensions/filters/http/ext_proc/http_client/client_base.h"
+
+namespace Envoy {
+namespace Extensions {
+namespace HttpFilters {
+namespace ExternalProcessing {
+
+class ExtProcHttpClient : public ClientBase,
+                          public Http::AsyncClient::Callbacks,
+                          public Logger::Loggable<Logger::Id::init> {
+public:
+  ExtProcHttpClient(const envoy::extensions::filters::http::ext_proc::v3::ExternalProcessor& config,
+                    Server::Configuration::ServerFactoryContext& context)
+      : config_(config), context_(context) {}
+
+  ~ExtProcHttpClient() { cancel(); }
+
+  void sendRequest() override {}
+  void cancel() override {}
+  void onBeforeFinalizeUpstreamSpan(Tracing::Span&, const Http::ResponseHeaderMap*) override {}
+
+  // Http::AsyncClient::Callbacks implemented by this class.
+  void onSuccess(const Http::AsyncClient::Request& request,
+                 Http::ResponseMessagePtr&& response) override;
+  void onFailure(const Http::AsyncClient::Request& request,
+                 Http::AsyncClient::FailureReason reason) override;
+
+  Server::Configuration::ServerFactoryContext& context() const { return context_; }
+
+private:
+  void onError();
+  envoy::extensions::filters::http::ext_proc::v3::ExternalProcessor config_;
+  Server::Configuration::ServerFactoryContext& context_;
+};
+
+} // namespace ExternalProcessing
+} // namespace HttpFilters
+} // namespace Extensions
+} // namespace Envoy

test/extensions/filters/http/ext_proc/http_client/BUILD

@@ -0,0 +1,26 @@
+load(
+    "//bazel:envoy_build_system.bzl",
+    "envoy_package",
+)
+load(
+    "//test/extensions:extensions_build_system.bzl",
+    "envoy_extension_cc_test",
+)
+
+licenses(["notice"])  # Apache 2
+
+envoy_package()
+
+envoy_extension_cc_test(
+    name = "http_client_test",
+    size = "small",
+    srcs = ["http_client_test.cc"],
+    extension_names = ["envoy.filters.http.ext_proc"],
+    tags = ["skip_on_windows"],
+    deps = [
+        "//source/common/http:message_lib",
+        "//source/extensions/filters/http/ext_proc/http_client:http_client_lib",
+        "//test/mocks/server:factory_context_mocks",
+        "@envoy_api//envoy/extensions/filters/http/ext_proc/v3:pkg_cc_proto",
+    ],
+)

test/extensions/filters/http/ext_proc/http_client/http_client_test.cc

@@ -0,0 +1,65 @@
+#include "envoy/extensions/filters/http/ext_proc/v3/ext_proc.pb.h"
+
+#include "source/common/http/message_impl.h"
+#include "source/extensions/filters/http/ext_proc/http_client/http_client_impl.h"
+
+#include "test/mocks/server/server_factory_context.h"
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace Envoy {
+namespace Extensions {
+namespace HttpFilters {
+namespace ExternalProcessing {
+namespace {
+
+class ExtProcHttpClientTest : public testing::Test {
+public:
+  ~ExtProcHttpClientTest() override = default;
+
+  void SetUp() override { client_ = std::make_unique<ExtProcHttpClient>(config_, context_); }
+
+protected:
+  envoy::extensions::filters::http::ext_proc::v3::ExternalProcessor config_;
+  testing::NiceMock<Server::Configuration::MockServerFactoryContext> context_;
+  Upstream::MockClusterManager& cm_{context_.cluster_manager_};
+  std::unique_ptr<ExtProcHttpClient> client_;
+  testing::NiceMock<Http::MockAsyncClientRequest> async_request_{
+      &cm_.thread_local_cluster_.async_client_};
+};
+
+TEST_F(ExtProcHttpClientTest, Basic) {
+  SetUp();
+  client_->sendRequest();
+  client_->cancel();
+  client_->context();
+  Tracing::MockSpan parent_span;
+  client_->onBeforeFinalizeUpstreamSpan(parent_span, nullptr);
+  Http::AsyncClient::FailureReason reason = Envoy::Http::AsyncClient::FailureReason::Reset;
+  client_->onFailure(async_request_, reason);
+
+  Http::ResponseHeaderMapPtr resp_headers_ok(new Http::TestResponseHeaderMapImpl({
+      {":status", "200"},
+  }));
+  Http::ResponseMessagePtr response_ok(new Http::ResponseMessageImpl(std::move(resp_headers_ok)));
+  client_->onSuccess(async_request_, std::move(response_ok));
+
+  Http::ResponseHeaderMapPtr resp_headers(new Http::TestResponseHeaderMapImpl({
+      {":status", "403"},
+  }));
+  Http::ResponseMessagePtr response(new Http::ResponseMessageImpl(std::move(resp_headers)));
+  client_->onSuccess(async_request_, std::move(response));
+
+  Http::ResponseHeaderMapPtr resp_headers_foo(new Http::TestResponseHeaderMapImpl({
+      {":status", "foo"},
+  }));
+  Http::ResponseMessagePtr response_foo(new Http::ResponseMessageImpl(std::move(resp_headers_foo)));
+  client_->onSuccess(async_request_, std::move(response_foo));
+}
+
+} // namespace
+} // namespace ExternalProcessing
+} // namespace HttpFilters
+} // namespace Extensions
+} // namespace Envoy