Adding proto only Request Source Config factory

api/request_source/request_source_plugin.proto

@@ -7,7 +7,7 @@ import "google/protobuf/wrappers.proto";
 import "validate/validate.proto";
 import "api/client/options.proto";
 
-// Configuration for FileBasedPluginRequestSource (plugin name:
+// Configuration for OptionsListFromFileRequestSourceFactory (plugin name:
 // "nighthawk.file-based-request-source-plugin")
 // The factory will load the RequestOptionsList from the file, and then passes it to the
 // requestSource it generates. The resulting request source will loop over the RequestOptionsList it
@@ -25,6 +25,18 @@ message FileBasedPluginConfig {
   google.protobuf.UInt32Value max_file_size = 3 [(validate.rules).uint32 = {lte: 1000000}];
 }
 
+// Configuration for OptionsListFromProtoRequestSourceFactory (plugin name:
+// "nighthawk.in-line-options-list-request-source-plugin") that uses rpc
+message InLinePluginConfig {
+  // The options_list will be used to generate Requests in the RequestSource.
+  nighthawk.client.RequestOptionsList options_list = 1;
+  // The pluginfactory makes requestSources that will generate requests from the RequestOptionList
+  // up to num_requests number of times. If num_requests exceeds the number of RequestOptions in the
+  // RequestOptionList located in the file at file_path, it will loop. num_requests = 0 means no
+  // limit on the number of requests to be produced.
+  google.protobuf.UInt32Value num_requests = 2 [(validate.rules).uint32 = {gte: 0, lte: 1000000}];
+}
+
 // Configuration for StubPluginRequestSource (plugin name: "nighthawk.stub-request-source-plugin")
 // The plugin does nothing. This is for testing and comparison of the Request Source Plugin Factory
 // mechanism using a minimal version of plugin that does not require a more complicated proto or

source/request_source/request_options_list_plugin_impl.cc

@@ -45,6 +45,36 @@ RequestSourcePtr OptionsListFromFileRequestSourceFactory::createRequestSourcePlu
 
 REGISTER_FACTORY(OptionsListFromFileRequestSourceFactory, RequestSourcePluginConfigFactory);
 
+std::string OptionsListFromProtoRequestSourceFactory::name() const {
+  return "nighthawk.in-line-options-list-request-source-plugin";
+}
+
+Envoy::ProtobufTypes::MessagePtr
+OptionsListFromProtoRequestSourceFactory::createEmptyConfigProto() {
+  return std::make_unique<nighthawk::request_source::InLinePluginConfig>();
+}
+
+RequestSourcePtr OptionsListFromProtoRequestSourceFactory::createRequestSourcePlugin(
+    const Envoy::Protobuf::Message& message, Envoy::Api::Api&,
+    Envoy::Http::RequestHeaderMapPtr header) {
+  const auto& any = dynamic_cast<const Envoy::ProtobufWkt::Any&>(message);
+  nighthawk::request_source::InLinePluginConfig config;
+  Envoy::MessageUtil::unpackTo(any, config);
+  // Locking to avoid issues with multiple threads calling this at the same time and trying to set
+  // the options_list_
+  {
+    Envoy::Thread::LockGuard lock_guard(options_list_lock_);
+    // Only loading the config into memory the first time.
+    if (options_list_.options_size() == 0) {
+      options_list_ = config.options_list();
+    }
+  }
+  return std::make_unique<RequestOptionsListRequestSource>(config.num_requests().value(),
+                                                           std::move(header), options_list_);
+}
+
+REGISTER_FACTORY(OptionsListFromProtoRequestSourceFactory, RequestSourcePluginConfigFactory);
+
 RequestOptionsListRequestSource::RequestOptionsListRequestSource(
     const uint32_t total_requests, Envoy::Http::RequestHeaderMapPtr header,
     const nighthawk::client::RequestOptionsList& options_list)
@@ -72,7 +102,8 @@ RequestGenerator RequestOptionsListRequestSource::get() {
     header->setMethod(envoy::config::core::v3::RequestMethod_Name(request_option.request_method()));
     const uint32_t content_length = request_option.request_body_size().value();
     if (content_length > 0) {
-      header->setContentLength(content_length);
+      header->setContentLength(
+          content_length); // Content length is used later in stream_decoder to populate the body
     }
     for (const envoy::config::core::v3::HeaderValueOption& option_header :
          request_option.request_headers()) {

source/request_source/request_options_list_plugin_impl.h

@@ -81,4 +81,36 @@ class OptionsListFromFileRequestSourceFactory : public virtual RequestSourcePlug
 // This factory will be activated through RequestSourceFactory in factories.h
 DECLARE_FACTORY(OptionsListFromFileRequestSourceFactory);
 
+// Factory that creates a RequestOptionsListRequestSource from a InLinePluginConfig proto.
+// Registered as an Envoy plugin.
+// Implementation of RequestSourceConfigFactory which produces a RequestSource that keeps an
+// RequestOptionsList in memory, and loads it with the RequestOptions passed to it from the config.
+// All plugins configuration are specified in the request_source_plugin.proto. Usage: assume you are
+// passed an appropriate Any type object called config, an Api object called api, and a default
+// header called header. auto& config_factory =
+//     Envoy::Config::Utility::getAndCheckFactoryByName<RequestSourcePluginConfigFactory>(
+//         "nighthawk.in-line-options-list-request-source-plugin");
+// RequestSourcePtr plugin =
+//     config_factory.createRequestSourcePlugin(config, std::move(api), std::move(header));
+
+class OptionsListFromProtoRequestSourceFactory : public virtual RequestSourcePluginConfigFactory {
+public:
+  std::string name() const override;
+  Envoy::ProtobufTypes::MessagePtr createEmptyConfigProto() override;
+
+  // This implementation is not thread safe. Only the first call to createRequestSourcePlugin will
+  // load the options list into memory and subsequent calls just make a copy of the options_list
+  // that was already loaded.
+  RequestSourcePtr createRequestSourcePlugin(const Envoy::Protobuf::Message& message,
+                                             Envoy::Api::Api& api,
+                                             Envoy::Http::RequestHeaderMapPtr header) override;
+
+private:
+  Envoy::Thread::MutexBasicLockable options_list_lock_;
+  nighthawk::client::RequestOptionsList options_list_;
+};
+
+// This factory will be activated through RequestSourceFactory in factories.h
+DECLARE_FACTORY(OptionsListFromProtoRequestSourceFactory);
+
 } // namespace Nighthawk

test/request_source/request_source_plugin_test.cc

@@ -18,6 +18,7 @@ namespace Nighthawk {
 
 namespace {
 using nighthawk::request_source::FileBasedPluginConfig;
+using nighthawk::request_source::InLinePluginConfig;
 using nighthawk::request_source::StubPluginConfig;
 using ::testing::NiceMock;
 using ::testing::Test;
@@ -43,6 +44,19 @@ class FileBasedRequestSourcePluginTest : public Test {
   }
 };
 
+class InLineRequestSourcePluginTest : public Test {
+public:
+  InLineRequestSourcePluginTest() : api_(Envoy::Api::createApiForTest(stats_store_)) {}
+  Envoy::Stats::MockIsolatedStatsStore stats_store_;
+  Envoy::Api::ApiPtr api_;
+  nighthawk::request_source::InLinePluginConfig
+  MakeInLinePluginConfig(nighthawk::client::RequestOptionsList options_list, int num_requests) {
+    nighthawk::request_source::InLinePluginConfig config;
+    *config.mutable_options_list() = std::move(options_list);
+    config.mutable_num_requests()->set_value(num_requests);
+    return config;
+  }
+};
 TEST_F(StubRequestSourcePluginTest, CreateEmptyConfigProtoCreatesCorrectType) {
   auto& config_factory =
       Envoy::Config::Utility::getAndCheckFactoryByName<RequestSourcePluginConfigFactory>(
@@ -155,7 +169,6 @@ TEST_F(FileBasedRequestSourcePluginTest,
        CreateRequestSourcePluginWithMoreNumRequestsThanInFileGetsWorkingRequestGeneratorThatLoops) {
   nighthawk::request_source::FileBasedPluginConfig config = MakeFileBasedPluginConfigWithTestYaml(
       TestEnvironment::runfilesPath("test/request_source/test_data/test-config.yaml"));
-  config.mutable_num_requests()->set_value(4);
   Envoy::ProtobufWkt::Any config_any;
   config_any.PackFrom(config);
   auto& config_factory =
@@ -175,5 +188,96 @@ TEST_F(FileBasedRequestSourcePluginTest,
   EXPECT_EQ(header2->getPathValue(), "/b");
   EXPECT_EQ(header3->getPathValue(), "/a");
 }
+
+TEST_F(InLineRequestSourcePluginTest, CreateEmptyConfigProtoCreatesCorrectType) {
+  auto& config_factory =
+      Envoy::Config::Utility::getAndCheckFactoryByName<RequestSourcePluginConfigFactory>(
+          "nighthawk.in-line-options-list-request-source-plugin");
+  const Envoy::ProtobufTypes::MessagePtr empty_config = config_factory.createEmptyConfigProto();
+  const nighthawk::request_source::InLinePluginConfig expected_config;
+  EXPECT_EQ(empty_config->DebugString(), expected_config.DebugString());
+  EXPECT_TRUE(Envoy::MessageUtil()(*empty_config, expected_config));
+}
+
+TEST_F(InLineRequestSourcePluginTest, FactoryRegistrationUsesCorrectPluginName) {
+  nighthawk::request_source::InLinePluginConfig config;
+  Envoy::ProtobufWkt::Any config_any;
+  config_any.PackFrom(config);
+  auto& config_factory =
+      Envoy::Config::Utility::getAndCheckFactoryByName<RequestSourcePluginConfigFactory>(
+          "nighthawk.in-line-options-list-request-source-plugin");
+  EXPECT_EQ(config_factory.name(), "nighthawk.in-line-options-list-request-source-plugin");
+}
+
+TEST_F(InLineRequestSourcePluginTest, CreateRequestSourcePluginCreatesCorrectPluginType) {
+  Envoy::MessageUtil util;
+  nighthawk::client::RequestOptionsList options_list;
+  util.loadFromFile(TestEnvironment::runfilesPath("test/request_source/test_data/test-config.yaml"),
+                    options_list, Envoy::ProtobufMessage::getStrictValidationVisitor(), *api_,
+                    true);
+  nighthawk::request_source::InLinePluginConfig config = MakeInLinePluginConfig(options_list, 2);
+  Envoy::ProtobufWkt::Any config_any;
+  config_any.PackFrom(config);
+  auto& config_factory =
+      Envoy::Config::Utility::getAndCheckFactoryByName<RequestSourcePluginConfigFactory>(
+          "nighthawk.in-line-options-list-request-source-plugin");
+  auto header = Envoy::Http::RequestHeaderMapImpl::create();
+  RequestSourcePtr plugin =
+      config_factory.createRequestSourcePlugin(config_any, *api_, std::move(header));
+  EXPECT_NE(dynamic_cast<RequestOptionsListRequestSource*>(plugin.get()), nullptr);
+}
+TEST_F(InLineRequestSourcePluginTest,
+       CreateRequestSourcePluginGetsWorkingRequestGeneratorThatEndsAtNumRequest) {
+  Envoy::MessageUtil util;
+  nighthawk::client::RequestOptionsList options_list;
+  util.loadFromFile(TestEnvironment::runfilesPath("test/request_source/test_data/test-config.yaml"),
+                    options_list, Envoy::ProtobufMessage::getStrictValidationVisitor(), *api_,
+                    true);
+  nighthawk::request_source::InLinePluginConfig config = MakeInLinePluginConfig(options_list, 2);
+  Envoy::ProtobufWkt::Any config_any;
+  config_any.PackFrom(config);
+  auto& config_factory =
+      Envoy::Config::Utility::getAndCheckFactoryByName<RequestSourcePluginConfigFactory>(
+          "nighthawk.in-line-options-list-request-source-plugin");
+  auto header = Envoy::Http::RequestHeaderMapImpl::create();
+  RequestSourcePtr plugin =
+      config_factory.createRequestSourcePlugin(config_any, *api_, std::move(header));
+  Nighthawk::RequestGenerator generator = plugin->get();
+  Nighthawk::RequestPtr request = generator();
+  Nighthawk::RequestPtr request2 = generator();
+  Nighthawk::RequestPtr request3 = generator();
+  Nighthawk::HeaderMapPtr header1 = request->header();
+  Nighthawk::HeaderMapPtr header2 = request2->header();
+  EXPECT_EQ(header1->getPathValue(), "/a");
+  EXPECT_EQ(header2->getPathValue(), "/b");
+  EXPECT_EQ(request3, nullptr);
+}
+TEST_F(InLineRequestSourcePluginTest,
+       CreateRequestSourcePluginWithMoreNumRequestsThanInFileGetsWorkingRequestGeneratorThatLoops) {
+  Envoy::MessageUtil util;
+  nighthawk::client::RequestOptionsList options_list;
+  util.loadFromFile(TestEnvironment::runfilesPath("test/request_source/test_data/test-config.yaml"),
+                    options_list, Envoy::ProtobufMessage::getStrictValidationVisitor(), *api_,
+                    true);
+  nighthawk::request_source::InLinePluginConfig config = MakeInLinePluginConfig(options_list, 4);
+  Envoy::ProtobufWkt::Any config_any;
+  config_any.PackFrom(config);
+  auto& config_factory =
+      Envoy::Config::Utility::getAndCheckFactoryByName<RequestSourcePluginConfigFactory>(
+          "nighthawk.in-line-options-list-request-source-plugin");
+  auto header = Envoy::Http::RequestHeaderMapImpl::create();
+  RequestSourcePtr plugin =
+      config_factory.createRequestSourcePlugin(config_any, *api_, std::move(header));
+  Nighthawk::RequestGenerator generator = plugin->get();
+  Nighthawk::RequestPtr request = generator();
+  Nighthawk::RequestPtr request2 = generator();
+  Nighthawk::RequestPtr request3 = generator();
+  Nighthawk::HeaderMapPtr header1 = request->header();
+  Nighthawk::HeaderMapPtr header2 = request2->header();
+  Nighthawk::HeaderMapPtr header3 = request3->header();
+  EXPECT_EQ(header1->getPathValue(), "/a");
+  EXPECT_EQ(header2->getPathValue(), "/b");
+  EXPECT_EQ(header3->getPathValue(), "/a");
+}
 } // namespace
 } // namespace Nighthawk