Adding config factory

api/client/options.proto

@@ -18,6 +18,12 @@ message RequestOptions {
   google.protobuf.UInt32Value request_body_size = 3 [(validate.rules).uint32 = {lte: 4194304}];
 }
 
+// Used for providing multiple request options, especially for RequestSourcePlugins.
+message RequestOptionsList {
+  // Each option is used for a separate request to be sent by the requestSource.
+  repeated RequestOptions options = 1;
+}
+
 // Configures a remote gRPC source that will deliver to-be-replayed request data to Nighthawks
 // workers.
 message RequestSource {

api/request_source/BUILD

@@ -16,6 +16,18 @@ api_cc_py_proto_library(
     ],
 )
 
+api_cc_py_proto_library(
+    name = "request_source_plugin",
+    srcs = [
+        "request_source_plugin.proto",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        "@envoy_api//envoy/config/core/v3:pkg",
+        "@nighthawk//api/client:base",
+    ],
+)
+
 cc_grpc_library(
     name = "grpc_request_source_service_lib",
     srcs = [

api/request_source/request_source_plugin.proto

@@ -0,0 +1,35 @@
+syntax = "proto3";
+
+package nighthawk.request_source;
+
+import "google/protobuf/wrappers.proto";
+import "validate/validate.proto";
+import "api/client/options.proto";
+
+// Configuration for DummyPluginRequestSource (plugin name: "nighthawk.dummy-request-source-plugin")
+// that does nothing
+message DummyPluginRequestSourceConfig {
+  // Dummy input value.
+  google.protobuf.DoubleValue dummy_value = 1;
+}
+
+// Configuration for RPCPluginRequestSource (plugin name: "nighthawk.rpc-request-source-plugin")
+// that uses rpc
+message RPCPluginRequestSourceConfig {
+  string uri = 1;
+}
+
+// Configuration for FileBasedPluginRequestSource (plugin name:
+// "nighthawk.file-based-request-source-plugin") that uses rpc
+message FileBasedPluginRequestSourceConfig {
+  string file_path = 1;
+  google.protobuf.UInt32Value num_requests = 2 [(validate.rules).uint32 = {gte: 0, lte: 1000000}];
+  google.protobuf.UInt32Value max_file_size = 3;
+}
+
+// Configuration for RequestOptionsListPluginRequestSource (plugin name:
+// "nighthawk.request-options-list-request-source-plugin") that uses rpc
+message RequestOptionsListPluginRequestSourceConfig {
+  nighthawk.client.RequestOptionsList options_list = 1;
+  google.protobuf.UInt32Value num_requests = 2 [(validate.rules).uint32 = {gte: 0, lte: 1000000}];
+}

include/nighthawk/common/BUILD

@@ -64,6 +64,21 @@ envoy_basic_cc_library(
     ],
 )
 
+envoy_basic_cc_library(
+    name = "request_source_plugin_config_factory_lib",
+    hdrs = [
+        "request_source_plugin_config_factory.h",
+    ],
+    include_prefix = "nighthawk/common",
+    deps = [
+        ":request_source_lib",
+        "//api/request_source:request_source_plugin_cc_proto",
+        "@envoy//include/envoy/common:base_includes",
+        "@envoy//include/envoy/config:typed_config_interface",
+        "@envoy//source/common/api:api_lib_with_external_headers",
+    ],
+)
+
 envoy_basic_cc_library(
     name = "request_source_lib",
     hdrs = [

include/nighthawk/common/request_source_plugin_config_factory.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "envoy/api/api.h"
+#include "envoy/common/pure.h"
+#include "envoy/config/typed_config.h"
+
+#include "nighthawk/common/request_source.h"
+
+namespace Nighthawk {
+
+/**
+ * A factory that must be implemented for each RequestSourcePlugin. It instantiates the specific
+ * RequestSourcePlugin class after unpacking the plugin-specific config proto.
+ */
+class RequestSourcePluginConfigFactory : public Envoy::Config::TypedFactory {
+public:
+  ~RequestSourcePluginConfigFactory() override = default;
+  std::string category() const override { return "nighthawk.request_source_plugin"; }
+  /**
+   * Instantiates the specific RequestSourcePlugin class. Casts |message| to Any, unpacks it to the
+   * plugin-specific proto, and passes the strongly typed proto to the plugin constructor.
+   *
+   * @param message Any typed_config proto taken from the TypedExtensionConfig.
+   *
+   * @param api Api parameter that contains timesystem, filesystem, and threadfactory.
+   *
+   * @return RequestSourcePtr Pointer to the new plugin instance.
+   *
+   * @throw Envoy::EnvoyException If the Any proto cannot be unpacked as the type expected by the
+   * plugin.
+   */
+  virtual RequestSourcePtr createRequestSourcePlugin(const Envoy::Protobuf::Message& typed_config,
+                                                     Envoy::Api::ApiPtr api,
+                                                     Envoy::Http::RequestHeaderMapPtr header) PURE;
+};
+
+} // namespace Nighthawk

source/common/BUILD

@@ -81,6 +81,30 @@ envoy_cc_library(
     ],
 )
 
+envoy_cc_library(
+    name = "request_source_plugin_impl",
+    srcs = [
+        "request_source_plugin_impl.cc",
+    ],
+    hdrs = [
+        "request_source_plugin_impl.h",
+    ],
+    repository = "@envoy",
+    visibility = ["//visibility:public"],
+    deps = [
+        ":nighthawk_common_lib",
+        ":request_impl_lib",
+        ":request_source_impl_lib",
+        "//include/nighthawk/common:request_source_plugin_config_factory_lib",
+        "@envoy//source/common/common:thread_lib_with_external_headers",
+        "@envoy//source/common/protobuf:message_validator_lib_with_external_headers",
+        "@envoy//source/common/protobuf:protobuf_with_external_headers",
+        "@envoy//source/common/protobuf:utility_lib_with_external_headers",
+        "@envoy//source/exe:platform_header_lib_with_external_headers",
+        "@envoy//source/exe:platform_impl_lib",
+    ],
+)
+
 envoy_cc_library(
     name = "version_linkstamp",
     srcs = ["version_linkstamp.cc"],

source/common/request_source_plugin_impl.cc

@@ -0,0 +1,151 @@
+#include "common/request_source_plugin_impl.h"
+
+#include "external/envoy/source/common/protobuf/message_validator_impl.h"
+#include "external/envoy/source/common/protobuf/utility.h"
+#include "external/envoy/source/exe/platform_impl.h"
+
+#include "api/client/options.pb.h"
+
+#include "common/request_impl.h"
+#include "common/request_source_impl.h"
+
+namespace Nighthawk {
+
+std::string DummyRequestSourcePluginConfigFactory::name() const {
+  return "nighthawk.dummy-request-source-plugin";
+}
+
+Envoy::ProtobufTypes::MessagePtr DummyRequestSourcePluginConfigFactory::createEmptyConfigProto() {
+  return std::make_unique<nighthawk::request_source::DummyPluginRequestSourceConfig>();
+}
+
+RequestSourcePtr DummyRequestSourcePluginConfigFactory::createRequestSourcePlugin(
+    const Envoy::Protobuf::Message& message, Envoy::Api::ApiPtr, Envoy::Http::RequestHeaderMapPtr) {
+  const auto& any = dynamic_cast<const Envoy::ProtobufWkt::Any&>(message);
+  nighthawk::request_source::DummyPluginRequestSourceConfig config;
+  Envoy::MessageUtil::unpackTo(any, config);
+  return std::make_unique<DummyRequestSource>(config);
+}
+
+REGISTER_FACTORY(DummyRequestSourcePluginConfigFactory, RequestSourcePluginConfigFactory);
+
+DummyRequestSource::DummyRequestSource(
+    const nighthawk::request_source::DummyPluginRequestSourceConfig& config)
+    : dummy_value_{config.has_dummy_value() ? config.dummy_value().value()
+                                            : std::numeric_limits<double>::infinity()} {}
+RequestGenerator DummyRequestSource::get() {
+
+  RequestGenerator request_generator = []() {
+    Envoy::Http::RequestHeaderMapPtr header = Envoy::Http::RequestHeaderMapImpl::create();
+    auto returned_request_impl = std::make_unique<RequestImpl>(std::move(header));
+    return returned_request_impl;
+  };
+  return request_generator;
+}
+
+void DummyRequestSource::initOnThread() {}
+
+std::string FileBasedRequestSourcePluginConfigFactory::name() const {
+  return "nighthawk.file-based-request-source-plugin";
+}
+
+Envoy::ProtobufTypes::MessagePtr
+FileBasedRequestSourcePluginConfigFactory::createEmptyConfigProto() {
+  return std::make_unique<nighthawk::request_source::FileBasedPluginRequestSourceConfig>();
+}
+
+RequestSourcePtr FileBasedRequestSourcePluginConfigFactory::createRequestSourcePlugin(
+    const Envoy::Protobuf::Message& message, Envoy::Api::ApiPtr api,
+    Envoy::Http::RequestHeaderMapPtr header) {
+  const auto& any = dynamic_cast<const Envoy::ProtobufWkt::Any&>(message);
+  nighthawk::request_source::FileBasedPluginRequestSourceConfig config;
+  Envoy::MessageUtil util;
+
+  util.unpackTo(any, config);
+  if (api->fileSystem().fileSize(config.file_path()) > config.max_file_size().value()) {
+    throw NighthawkException("file size must be less than max_file_size");
+  }
+  auto temp_list = std::make_unique<nighthawk::client::RequestOptionsList>();
+
+  // Locking to avoid issues with multiple threads reading the same file.
+  {
+    Envoy::Thread::LockGuard lock_guard(file_lock_);
+    // Reading the file only the first time.
+    if (options_list_.options_size() == 0) {
+      util.loadFromFile(config.file_path(), options_list_,
+                        Envoy::ProtobufMessage::getStrictValidationVisitor(), *api, true);
+    }
+    temp_list->CopyFrom(options_list_);
+  }
+  return std::make_unique<RequestOptionsListRequestSource>(config.num_requests().value(),
+                                                           std::move(header), std::move(temp_list));
+}
+
+REGISTER_FACTORY(FileBasedRequestSourcePluginConfigFactory, RequestSourcePluginConfigFactory);
+
+RequestOptionsListRequestSource::RequestOptionsListRequestSource(
+    const uint32_t request_max, Envoy::Http::RequestHeaderMapPtr header,
+    std::unique_ptr<nighthawk::client::RequestOptionsList> options_list)
+    : header_(std::move(header)), options_list_(std::move(options_list)),
+      request_max_(request_max) {}
+
+RequestGenerator RequestOptionsListRequestSource::get() {
+  uint32_t counter = 0;
+  request_count_.push_back(counter);
+  uint32_t& lambda_counter = request_count_.back();
+  RequestGenerator request_generator = [this, lambda_counter]() mutable -> RequestPtr {
+    // if request_max is 0, then we never stop generating requests.
+    if (lambda_counter >= request_max_ && request_max_ != 0) {
+      return nullptr;
+    }
+
+    // Increment the counter and get the request_option from the list for the current iteration.
+    auto index = lambda_counter % options_list_->options_size();
+    nighthawk::client::RequestOptions request_option = options_list_->options().at(index);
+    lambda_counter++;
+
+    // Initialize the header with the values from the default header.
+    Envoy::Http::RequestHeaderMapPtr header = Envoy::Http::RequestHeaderMapImpl::create();
+    Envoy::Http::HeaderMapImpl::copyFrom(*header, *header_);
+
+    // Override the default values with the values from the request_option
+    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);
+    }
+    for (const auto& option_header : request_option.request_headers()) {
+      auto lower_case_key = Envoy::Http::LowerCaseString(std::string(option_header.header().key()));
+      header->setCopy(lower_case_key, std::string(option_header.header().value()));
+    }
+    return std::make_unique<RequestImpl>(std::move(header));
+  };
+  return request_generator;
+}
+
+void RequestOptionsListRequestSource::initOnThread() {}
+
+std::string RequestOptionsListRequestSourcePluginConfigFactory::name() const {
+  return "nighthawk.request-options-list-request-source-plugin";
+}
+
+Envoy::ProtobufTypes::MessagePtr
+RequestOptionsListRequestSourcePluginConfigFactory::createEmptyConfigProto() {
+  return std::make_unique<nighthawk::request_source::RequestOptionsListPluginRequestSourceConfig>();
+}
+
+RequestSourcePtr RequestOptionsListRequestSourcePluginConfigFactory::createRequestSourcePlugin(
+    const Envoy::Protobuf::Message& message, Envoy::Api::ApiPtr,
+    Envoy::Http::RequestHeaderMapPtr header) {
+  const auto& any = dynamic_cast<const Envoy::ProtobufWkt::Any&>(message);
+  nighthawk::request_source::RequestOptionsListPluginRequestSourceConfig config;
+  Envoy::MessageUtil::unpackTo(any, config);
+  auto temp_list = std::make_unique<nighthawk::client::RequestOptionsList>(config.options_list());
+  return std::make_unique<RequestOptionsListRequestSource>(config.num_requests().value(),
+                                                           std::move(header), std::move(temp_list));
+}
+
+REGISTER_FACTORY(RequestOptionsListRequestSourcePluginConfigFactory,
+                 RequestSourcePluginConfigFactory);
+
+} // namespace Nighthawk