Factory plugin implementation

source/client/factories_impl.cc

@@ -17,6 +17,8 @@
 #include "client/output_collector_impl.h"
 #include "client/output_formatter_impl.h"
 
+#include "request_source/request_options_list_plugin_impl.h"
+
 using namespace std::chrono_literals;
 
 namespace Nighthawk {
@@ -117,8 +119,8 @@ OutputFormatterPtr OutputFormatterFactoryImpl::create(
   }
 }
 
-RequestSourceFactoryImpl::RequestSourceFactoryImpl(const Options& options)
-    : OptionBasedFactoryImpl(options) {}
+RequestSourceFactoryImpl::RequestSourceFactoryImpl(const Options& options, Envoy::Api::Api& api)
+    : OptionBasedFactoryImpl(options), api_(api) {}
 
 void RequestSourceFactoryImpl::setRequestHeader(Envoy::Http::RequestHeaderMap& header,
                                                 absl::string_view key,
@@ -168,18 +170,39 @@ RequestSourceFactoryImpl::create(const Envoy::Upstream::ClusterManagerPtr& clust
   for (const auto& option_header : request_options.request_headers()) {
     setRequestHeader(*header, option_header.header().key(), option_header.header().value());
   }
-
   if (!options_.requestSource().empty()) {
     RELEASE_ASSERT(!service_cluster_name.empty(), "expected cluster name to be set");
     // We pass in options_.requestsPerSecond() as the header buffer length so the grpc client
     // will shoot for maintaining an amount of headers of at least one second.
     return std::make_unique<RemoteRequestSourceImpl>(cluster_manager, dispatcher, scope,
                                                      service_cluster_name, std::move(header),
                                                      options_.requestsPerSecond());
+  } else if (options_.requestSourcePluginConfig().has_value()) {
+    absl::StatusOr<RequestSourcePtr> plugin_or = LoadRequestSourcePlugin(
+        options_.requestSourcePluginConfig().value(), api_, std::move(header));
+    RELEASE_ASSERT(plugin_or.ok(),
+                   absl::StrCat("Request Source plugin loading error should have been caught "
+                                "during input validation: ",
+                                plugin_or.status().message()));
+    RequestSourcePtr request_source = std::move(plugin_or.value());
+    return request_source;
   } else {
     return std::make_unique<StaticRequestSourceImpl>(std::move(header));
   }
 }
+absl::StatusOr<RequestSourcePtr> RequestSourceFactoryImpl::LoadRequestSourcePlugin(
+    const envoy::config::core::v3::TypedExtensionConfig& config, Envoy::Api::Api& api,
+    Envoy::Http::RequestHeaderMapPtr header) const {
+  try {
+    auto& config_factory =
+        Envoy::Config::Utility::getAndCheckFactoryByName<RequestSourcePluginConfigFactory>(
+            config.name());
+    return config_factory.createRequestSourcePlugin(config.typed_config(), api, std::move(header));
+  } catch (const Envoy::EnvoyException& e) {
+    return absl::InvalidArgumentError(
+        absl::StrCat("Could not load plugin: ", config.name(), ": ", e.what()));
+  }
+}
 
 TerminationPredicateFactoryImpl::TerminationPredicateFactoryImpl(const Options& options)
     : OptionBasedFactoryImpl(options) {}

source/client/factories_impl.h

@@ -9,6 +9,9 @@
 #include "nighthawk/common/termination_predicate.h"
 #include "nighthawk/common/uri.h"
 
+#include "external/envoy/source/common/common/statusor.h"
+#include "external/envoy/source/common/config/utility.h"
+
 #include "common/platform_util_impl.h"
 
 namespace Nighthawk {
@@ -58,14 +61,30 @@ class OutputFormatterFactoryImpl : public OutputFormatterFactory {
 
 class RequestSourceFactoryImpl : public OptionBasedFactoryImpl, public RequestSourceFactory {
 public:
-  RequestSourceFactoryImpl(const Options& options);
+  RequestSourceFactoryImpl(const Options& options, Envoy::Api::Api& api);
   RequestSourcePtr create(const Envoy::Upstream::ClusterManagerPtr& cluster_manager,
                           Envoy::Event::Dispatcher& dispatcher, Envoy::Stats::Scope& scope,
                           absl::string_view service_cluster_name) const override;
 
+protected:
+  Envoy::Api::Api& api_;
+
 private:
   void setRequestHeader(Envoy::Http::RequestHeaderMap& header, absl::string_view key,
                         absl::string_view value) const;
+  /**
+   * Instantiates a RequestSource using a RequestSourcePluginFactory based on the plugin name in
+   * |config|, unpacking the plugin-specific config proto within |config|. Validates the config
+   * proto.
+   *
+   * @param config Proto containing plugin name and plugin-specific config proto.
+   *
+   * @return absl::StatusOr<RequestSourcePtr> Initialized plugin or error status due to missing
+   * plugin or config proto validation error.
+   */
+  absl::StatusOr<RequestSourcePtr>
+  LoadRequestSourcePlugin(const envoy::config::core::v3::TypedExtensionConfig& config,
+                          Envoy::Api::Api& api, Envoy::Http::RequestHeaderMapPtr header) const;
 };
 
 class TerminationPredicateFactoryImpl : public OptionBasedFactoryImpl,

source/client/process_impl.cc

@@ -104,7 +104,8 @@ ProcessImpl::ProcessImpl(const Options& options, Envoy::Event::TimeSystem& time_
                                               generator_)),
       dispatcher_(api_->allocateDispatcher("main_thread")), benchmark_client_factory_(options),
       termination_predicate_factory_(options), sequencer_factory_(options),
-      request_generator_factory_(options), options_(options), init_manager_("nh_init_manager"),
+      request_generator_factory_(options, *api_), options_(options),
+      init_manager_("nh_init_manager"),
       local_info_(new Envoy::LocalInfo::LocalInfoImpl(
           {}, Envoy::Network::Utility::getLocalAddress(Envoy::Network::Address::IpVersion::v4),
           "nighthawk_service_zone", "nighthawk_service_cluster", "nighthawk_service_node")),

test/factories_test.cc

@@ -52,17 +52,61 @@ TEST_F(FactoriesTest, CreateBenchmarkClient) {
   EXPECT_NE(nullptr, benchmark_client.get());
 }
 
+TEST_F(FactoriesTest, CreateRequestSourcePlugin) {
+  absl::optional<envoy::config::core::v3::TypedExtensionConfig> request_source_plugin_config;
+  std::string request_source_plugin_config_json =
+      "{"
+      "name:\"nighthawk.in-line-options-list-request-source-plugin\","
+      "typed_config:{"
+      "\"@type\":\"type.googleapis.com/"
+      "nighthawk.request_source.InLineOptionsListRequestSourceConfig\","
+      "options_list:{"
+      "options:[{request_method:\"1\",request_headers:[{header:{key:\":path\",value:\"inlinepath\"}"
+      "}]}]"
+      "},"
+      "}"
+      "}";
+  request_source_plugin_config.emplace(envoy::config::core::v3::TypedExtensionConfig());
+  Envoy::MessageUtil::loadFromJson(request_source_plugin_config_json,
+                                   request_source_plugin_config.value(),
+                                   Envoy::ProtobufMessage::getStrictValidationVisitor());
+  EXPECT_CALL(options_, requestMethod()).Times(1);
+  EXPECT_CALL(options_, requestBodySize()).Times(1);
+  EXPECT_CALL(options_, uri()).Times(2).WillRepeatedly(Return("http://foo/"));
+  EXPECT_CALL(options_, requestSource()).Times(1);
+  EXPECT_CALL(options_, requestSourcePluginConfig())
+      .Times(2)
+      .WillRepeatedly(ReturnRef(request_source_plugin_config));
+  auto cmd = std::make_unique<nighthawk::client::CommandLineOptions>();
+  auto request_headers = cmd->mutable_request_options()->add_request_headers();
+  request_headers->mutable_header()->set_key("foo");
+  request_headers->mutable_header()->set_value("bar");
+  EXPECT_CALL(options_, toCommandLineOptions()).Times(1).WillOnce(Return(ByMove(std::move(cmd))));
+  RequestSourceFactoryImpl factory(options_, *api_);
+  Envoy::Upstream::ClusterManagerPtr cluster_manager;
+  auto request_source = factory.create(cluster_manager, dispatcher_,
+                                       *stats_store_.createScope("foo."), "requestsource");
+  EXPECT_NE(nullptr, request_source.get());
+  auto generator = request_source->get();
+  auto request = generator();
+  EXPECT_EQ("inlinepath", request->header()->getPathValue());
+}
+
 TEST_F(FactoriesTest, CreateRequestSource) {
+  absl::optional<envoy::config::core::v3::TypedExtensionConfig> request_source_plugin_config;
   EXPECT_CALL(options_, requestMethod()).Times(1);
   EXPECT_CALL(options_, requestBodySize()).Times(1);
   EXPECT_CALL(options_, uri()).Times(2).WillRepeatedly(Return("http://foo/"));
   EXPECT_CALL(options_, requestSource()).Times(1);
+  EXPECT_CALL(options_, requestSourcePluginConfig())
+      .Times(1)
+      .WillRepeatedly(ReturnRef(request_source_plugin_config));
   auto cmd = std::make_unique<nighthawk::client::CommandLineOptions>();
   auto request_headers = cmd->mutable_request_options()->add_request_headers();
   request_headers->mutable_header()->set_key("foo");
   request_headers->mutable_header()->set_value("bar");
   EXPECT_CALL(options_, toCommandLineOptions()).Times(1).WillOnce(Return(ByMove(std::move(cmd))));
-  RequestSourceFactoryImpl factory(options_);
+  RequestSourceFactoryImpl factory(options_, *api_);
   Envoy::Upstream::ClusterManagerPtr cluster_manager;
   auto request_generator = factory.create(cluster_manager, dispatcher_,
                                           *stats_store_.createScope("foo."), "requestsource");

test/integration/test_request_source_plugin.py

@@ -0,0 +1,62 @@
+"""Tests for the nighthawk_service binary."""
+
+import pytest
+import os
+
+from test.integration.integration_test_fixtures import (http_test_server_fixture, server_config)
+from test.integration import utility
+from test.integration import asserts
+
+
+def test_request_source_plugin_happy_flow(http_test_server_fixture):
+  """Test that the nighthawkClient can run with request-source-plugin option."""
+  request_source_config = """
+  {
+  name:"nighthawk.in-line-options-list-request-source-plugin",
+  typed_config:{
+  "@type":"type.googleapis.com/nighthawk.request_source.InLineOptionsListRequestSourceConfig",
+  options_list:{
+  options:[
+    {request_method:"1",request_body_size:"1",request_headers:[{header:{"key":"x-nighthawk-test-server-config","value":"{response_body_size:13}"}}]},
+    {request_method:"1",request_body_size:"2",request_headers:[{header:{"key":"x-nighthawk-test-server-config","value":"{response_body_size:17}"}}]},
+    ]
+  },
+  }
+  }"""
+  parsed_json, _ = http_test_server_fixture.runNighthawkClient([
+      "--termination-predicate", "benchmark.http_2xx:5", "--rps 10",
+      "--request-source-plugin-config %s" % request_source_config,
+      http_test_server_fixture.getTestServerRootUri(), "--request-header", "host: sni.com"
+  ])
+  counters = http_test_server_fixture.getNighthawkCounterMapFromJson(parsed_json)
+  global_histograms = http_test_server_fixture.getNighthawkGlobalHistogramsbyIdFromJson(parsed_json)
+  asserts.assertGreaterEqual(counters["benchmark.http_2xx"], 5)
+  asserts.assertEqual(int(global_histograms["benchmark_http_client.response_body_size"]["raw_max"]),
+                      17)
+  asserts.assertEqual(int(global_histograms["benchmark_http_client.response_body_size"]["raw_min"]),
+                      13)
+
+
+# TODO: This may be unnecessary, adding for additional integration coverage.
+def test_request_source_plugin_happy_flow_file_based(http_test_server_fixture):
+  """Test that the nighthawkClient can run with request-source-plugin option."""
+  base_folder = (os.path.dirname(os.path.abspath(os.path.dirname(__file__))))
+  test_file = base_folder + "/request_source/test_data/test-config.yaml"
+  request_source_config = """
+  {
+  name:"nighthawk.file-based-request-source-plugin",
+  typed_config:{
+  "@type":"type.googleapis.com/nighthawk.request_source.FileBasedOptionsListRequestSourceConfig",
+  file_path:"%s",
+  }
+  }""" % test_file
+  parsed_json, _ = http_test_server_fixture.runNighthawkClient([
+      "--rps 10",
+      "--request-source-plugin-config %s" % request_source_config,
+      http_test_server_fixture.getTestServerRootUri(), "--request-header", "host: sni.com"
+  ])
+  global_histograms = http_test_server_fixture.getNighthawkGlobalHistogramsbyIdFromJson(parsed_json)
+  asserts.assertEqual(int(global_histograms["benchmark_http_client.response_body_size"]["raw_max"]),
+                      17)
+  asserts.assertEqual(int(global_histograms["benchmark_http_client.response_body_size"]["raw_min"]),
+                      13)

test/request_source/test_data/test-config.yaml

@@ -1,13 +1,11 @@
 options:
-  - request_body_size: 10
+  - request_method: 1
+    request_body_size: 10
     request_headers:
-      - { header: { key: ":path", value: "/a" } }
-      - { header: { key: "foo", value: "bar" } }
-      - { header: { key: "foo", value: "bar2" } }
-      - { header: { key: "x-nh", value: "1" } }
-  - request_body_size: 10
+      - { header: { key: ":path", value: "/a" } }  
+      - { header: { key: "x-nighthawk-test-server-config", value: "{response_body_size:13}" } }
+  - request_method: 1
+    request_body_size: 10
     request_headers:
-      - { header: { key: ":path", value: "/b" } }
-      - { header: { key: "bar", value: "foo" } }
-      - { header: { key: "bar", value: "foo2" } }
-      - { header: { key: "x-nh", value: "2" } }  
+      - { header: { key: ":path", value: "/b" } }  
+      - { header: { key: "x-nighthawk-test-server-config", value: "{response_body_size:17}" } }