Fix formatting for PR

Signed-off-by: asingh-g <[email protected]>

Author: asingh-g

api/client/options.proto

@@ -162,7 +162,7 @@ message CommandLineOptions {
     Protocol protocol = 107;
   }
 
-  // Options for routing requests via a proxy. if set, requests 
+  // Options for routing requests via a proxy. if set, requests
   // are encapsulated and forwarded to a terminating proxy running at
   // tunnel_uri.
   // When the oneof_protocol field is set to H1 or H2, an HTTP CONNECT
@@ -185,7 +185,7 @@ message CommandLineOptions {
     // auto is recommended to avoid bottlenecking nighthawk with encapsulation
     // Default: auto.
     google.protobuf.StringValue tunnel_concurrency =
-    119; // [(validate.rules).string = {pattern: "^([0-9]*|auto)$"}];
+        119; // [(validate.rules).string = {pattern: "^([0-9]*|auto)$"}];
   }
 
   TunnelOptions tunnel_options = 114;

source/client/BUILD

@@ -50,16 +50,16 @@ envoy_cc_library(
         "//include/nighthawk/client:options_lib",
         "//source/common:nighthawk_common_lib",
         "@envoy//source/common/common:statusor_lib_with_external_headers",
+        "@envoy//source/common/formatter:formatter_extension_lib",
+        "@envoy//source/extensions/filters/network/tcp_proxy:config",
+        "@envoy//source/extensions/filters/udp/udp_proxy:config",
+        "@envoy//source/extensions/filters/udp/udp_proxy:udp_proxy_filter_lib",
+        "@envoy//source/extensions/filters/udp/udp_proxy/session_filters/http_capsule:config",
         "@envoy_api//envoy/config/bootstrap/v3:pkg_cc_proto",
         "@envoy_api//envoy/extensions/filters/network/tcp_proxy/v3:pkg_cc_proto",
         "@envoy_api//envoy/extensions/filters/udp/udp_proxy/session/dynamic_forward_proxy/v3:pkg_cc_proto",
-        "@envoy_api//envoy/extensions/filters/udp/udp_proxy/v3:pkg_cc_proto",
-        "@envoy//source/extensions/filters/udp/udp_proxy/session_filters/http_capsule:config",
         "@envoy_api//envoy/extensions/filters/udp/udp_proxy/session/http_capsule/v3:pkg_cc_proto",
-        "@envoy//source/extensions/filters/udp/udp_proxy:udp_proxy_filter_lib",
-        "@envoy//source/extensions/filters/network/tcp_proxy:config",
-        "@envoy//source/extensions/filters/udp/udp_proxy:config",
-        "@envoy//source/common/formatter:formatter_extension_lib",
+        "@envoy_api//envoy/extensions/filters/udp/udp_proxy/v3:pkg_cc_proto",
     ],
 )
 
@@ -130,7 +130,6 @@ envoy_cc_library(
         "@envoy//source/common/network:address_lib_with_external_headers",
         "@envoy//source/common/protobuf:message_validator_lib_with_external_headers",
         "@envoy//source/common/protobuf:utility_lib_with_external_headers",
-        "@envoy//source/exe:main_common_lib_with_external_headers",
         "@envoy//source/common/router:context_lib_with_external_headers",
         "@envoy//source/common/runtime:runtime_lib_with_external_headers",
         "@envoy//source/common/secret:secret_manager_impl_lib_with_external_headers",
@@ -145,6 +144,7 @@ envoy_cc_library(
         "@envoy//source/common/tracing:tracer_lib_with_external_headers",
         "@envoy//source/common/upstream:cluster_manager_lib_with_external_headers",
         "@envoy//source/exe:all_extensions_lib_with_external_headers",
+        "@envoy//source/exe:main_common_lib_with_external_headers",
         "@envoy//source/exe:platform_header_lib_with_external_headers",
         "@envoy//source/exe:platform_impl_lib",
         "@envoy//source/exe:process_wide_lib_with_external_headers",

source/client/options_impl.cc

@@ -1,5 +1,11 @@
 #include "source/client/options_impl.h"
 
+#include <sys/socket.h>
+
+#include <cerrno>
+#include <cstdint>
+#include <exception>
+
 #include "external/envoy/source/common/protobuf/message_validator_impl.h"
 #include "external/envoy/source/common/protobuf/protobuf.h"
 #include "external/envoy/source/common/protobuf/utility.h"
@@ -12,15 +18,10 @@
 #include "source/common/version_info.h"
 
 #include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_split.h"
 #include "absl/types/optional.h"
-#include "absl/strings/str_cat.h"
-
 #include "fmt/ranges.h"
-#include <cerrno>
-#include <cstdint>
-#include <exception>
-#include <sys/socket.h>
 
 namespace Nighthawk {
 namespace Client {
@@ -36,8 +37,8 @@ using ::nighthawk::client::Protocol;
 uint16_t OptionsImpl::GetAvailablePort(bool udp) {
   int family = (address_family_ == nighthawk::client::AddressFamily::V4) ? AF_INET : AF_INET6;
   int sock = socket(family, udp ? SOCK_DGRAM : SOCK_STREAM, udp ? 0 : IPPROTO_TCP);
-  if(sock < 0) {
-    throw NighthawkException(absl::StrCat("could not create socket: ", strerror(errno)) );
+  if (sock < 0) {
+    throw NighthawkException(absl::StrCat("could not create socket: ", strerror(errno)));
     return 0;
   }
 
@@ -53,52 +54,48 @@ uint16_t OptionsImpl::GetAvailablePort(bool udp) {
     struct sockaddr_in6 sin6;
   } addr;
   size_t size;
-  if(family ==  AF_INET){
+  if (family == AF_INET) {
     size = sizeof(sockaddr_in);
     memset(&addr, 0, size);
     addr.sin.sin_family = AF_INET;
     addr.sin.sin_addr.s_addr = INADDR_ANY;
     addr.sin.sin_port = 0;
-    }
-  else {
+  } else {
     size = sizeof(sockaddr_in6);
     memset(&addr, 0, size);
     addr.sin6.sin6_family = AF_INET6;
     addr.sin6.sin6_addr = in6addr_any;
-    addr.sin6.sin6_port = 0;  
+    addr.sin6.sin6_port = 0;
   }
 
-  if (bind(sock, reinterpret_cast<struct sockaddr *>(&addr), size) < 0) {
-      if(errno == EADDRINUSE) {
-          throw NighthawkException(absl::StrCat("Port allocated already in use"));
-      } else {     
-          throw NighthawkException(absl::StrCat("Could not bind to process: ", strerror(errno)) );
-      }
-      return 0;
+  if (bind(sock, reinterpret_cast<struct sockaddr*>(&addr), size) < 0) {
+    if (errno == EADDRINUSE) {
+      throw NighthawkException(absl::StrCat("Port allocated already in use"));
+    } else {
+      throw NighthawkException(absl::StrCat("Could not bind to process: ", strerror(errno)));
+    }
+    return 0;
   }
 
   socklen_t len = size;
-  if (getsockname(sock, reinterpret_cast<struct sockaddr *>(&addr), &len) == -1) {
-      throw NighthawkException(absl::StrCat("Could not get sock name: ", strerror(errno)) );
-      return 0;
+  if (getsockname(sock, reinterpret_cast<struct sockaddr*>(&addr), &len) == -1) {
+    throw NighthawkException(absl::StrCat("Could not get sock name: ", strerror(errno)));
+    return 0;
   }
 
-  uint16_t port = ntohs(family ==  AF_INET 
-  ? reinterpret_cast<struct sockaddr_in *>(&addr)->sin_port
-  : reinterpret_cast<struct sockaddr_in6 *>(&addr)->sin6_port);
+  uint16_t port =
+      ntohs(family == AF_INET ? reinterpret_cast<struct sockaddr_in*>(&addr)->sin_port
+                              : reinterpret_cast<struct sockaddr_in6*>(&addr)->sin6_port);
 
   // close the socket, freeing the port to be used later.
-  if (close (sock) < 0 ) {
-      throw NighthawkException(absl::StrCat("Could not close socket: ", strerror(errno)) );
-      return 0;
+  if (close(sock) < 0) {
+    throw NighthawkException(absl::StrCat("Could not close socket: ", strerror(errno)));
+    return 0;
   }
 
   return port;
-
 }
 
-
-
 OptionsImpl::OptionsImpl(int argc, const char* const* argv) {
   setNonTrivialDefaults();
   // Override some defaults, we are in CLI-mode.
@@ -159,8 +156,8 @@ OptionsImpl::OptionsImpl(int argc, const char* const* argv) {
       "{quic_protocol_options:{max_concurrent_streams:1}}",
       false, "", "string", cmd);
 
-      std::vector<std::string> tunnel_protocols = {"http1", "http2", "http3"};
-      TCLAP::ValuesConstraint<std::string> tunnel_protocols_allowed(tunnel_protocols);
+  std::vector<std::string> tunnel_protocols = {"http1", "http2", "http3"};
+  TCLAP::ValuesConstraint<std::string> tunnel_protocols_allowed(tunnel_protocols);
   TCLAP::ValueArg<std::string> tunnel_protocol(
       "", "tunnel-protocol",
       fmt::format(
@@ -170,7 +167,8 @@ OptionsImpl::OptionsImpl(int argc, const char* const* argv) {
           "and protocol = HTTP3 and tunnel_protocol = HTTP3"
           "When protocol is set to HTTP3 and tunneling is enabled, the CONNECT-UDP method is used"
           "Otherwise, the HTTP CONNECT method is used",
-          absl::AsciiStrToLower(nighthawk::client::Protocol_ProtocolOptions_Name(tunnel_protocol_))),
+          absl::AsciiStrToLower(
+              nighthawk::client::Protocol_ProtocolOptions_Name(tunnel_protocol_))),
       false, "", &tunnel_protocols_allowed, cmd);
   TCLAP::ValueArg<std::string> tunnel_uri(
       "", "tunnel-uri",
@@ -182,7 +180,8 @@ OptionsImpl::OptionsImpl(int argc, const char* const* argv) {
   TCLAP::ValueArg<std::string> tunnel_http3_protocol_options(
       "", "tunnel-http3-protocol-options",
       "Tunnel HTTP3 protocol options (envoy::config::core::v3::Http3ProtocolOptions) in json. If "
-      "specified, Nighthawk uses these HTTP3 protocol options when encapsulating requests. Only valid "
+      "specified, Nighthawk uses these HTTP3 protocol options when encapsulating requests. Only "
+      "valid "
       "with --tunnel-protocol http3.",
       false, "", "string", cmd);
   TCLAP::ValueArg<std::string> tunnel_tls_context(
@@ -208,8 +207,7 @@ OptionsImpl::OptionsImpl(int argc, const char* const* argv) {
       fmt::format(
           "The number of concurrent event loops that should be used. Specify 'auto' to let "
           "Nighthawk use half the threads specified via the concurrency flag for tunneling.",
-          "Default: auto",
-          tunnel_concurrency_),
+          "Default: auto", tunnel_concurrency_),
       false, "auto", "string", cmd);
 
   std::vector<std::string> log_levels = {"trace", "debug", "info", "warn", "error", "critical"};
@@ -797,31 +795,31 @@ OptionsImpl::OptionsImpl(int argc, const char* const* argv) {
   if (tunnel_protocol.isSet()) {
     std::string upper_cased = tunnel_protocol.getValue();
     absl::AsciiStrToUpper(&upper_cased);
-    RELEASE_ASSERT(nighthawk::client::Protocol::ProtocolOptions_Parse(upper_cased, &tunnel_protocol_),
-                   "Failed to parse tunnel protocol");
-    if(!tunnel_uri.isSet()){
+    RELEASE_ASSERT(
+        nighthawk::client::Protocol::ProtocolOptions_Parse(upper_cased, &tunnel_protocol_),
+        "Failed to parse tunnel protocol");
+    if (!tunnel_uri.isSet()) {
       throw MalformedArgvException("--tunnel-protocol requires --tunnel-uri");
     }
     tunnel_uri_ = tunnel_uri.getValue();
     encap_port_ = GetAvailablePort(/*udp=*/protocol_ == Protocol::HTTP3);
     tunnel_concurrency_ = tunnel_concurrency.getValue();
 
-  }
-  else if (tunnel_uri.isSet() ||tunnel_http3_protocol_options.isSet()
-        || tunnel_tls_context.isSet() || tunnel_concurrency.isSet()) {
+  } else if (tunnel_uri.isSet() || tunnel_http3_protocol_options.isSet() ||
+             tunnel_tls_context.isSet() || tunnel_concurrency.isSet()) {
     throw MalformedArgvException("tunnel flags require --tunnel-protocol");
   }
 
   if (!tunnel_tls_context.getValue().empty()) {
     try {
-      tunnel_tls_context_.emplace(envoy::extensions::transport_sockets::tls::v3::UpstreamTlsContext());
+      tunnel_tls_context_.emplace(
+          envoy::extensions::transport_sockets::tls::v3::UpstreamTlsContext());
       Envoy::MessageUtil::loadFromJson(tunnel_tls_context.getValue(), tunnel_tls_context_.value(),
                                        Envoy::ProtobufMessage::getStrictValidationVisitor());
-        } catch (const Envoy::EnvoyException& e) {
+    } catch (const Envoy::EnvoyException& e) {
       throw MalformedArgvException(e.what());
     }
-  }
-  else if(tunnel_protocol_ == Protocol::HTTP3){
+  } else if (tunnel_protocol_ == Protocol::HTTP3) {
     throw MalformedArgvException("--tunnel-tls-context is required to use --tunnel-protocol http3");
   }
 
@@ -841,12 +839,14 @@ OptionsImpl::OptionsImpl(int argc, const char* const* argv) {
     }
   }
 
-  if(tunnel_protocol.isSet()){
-    if(tunnel_protocol_ == Protocol::HTTP3 && protocol_ == Protocol::HTTP3){
-      throw MalformedArgvException("--protocol HTTP3 over --tunnel-protocol HTTP3 is not supported");
+  if (tunnel_protocol.isSet()) {
+    if (tunnel_protocol_ == Protocol::HTTP3 && protocol_ == Protocol::HTTP3) {
+      throw MalformedArgvException(
+          "--protocol HTTP3 over --tunnel-protocol HTTP3 is not supported");
     }
-    if(tunnel_protocol_ == Protocol::HTTP1 && protocol_ == Protocol::HTTP3){
-      throw MalformedArgvException("--protocol HTTP3 over --tunnel-protocol HTTP1 is not supported");
+    if (tunnel_protocol_ == Protocol::HTTP1 && protocol_ == Protocol::HTTP3) {
+      throw MalformedArgvException(
+          "--protocol HTTP3 over --tunnel-protocol HTTP1 is not supported");
     }
   }
 
@@ -863,7 +863,6 @@ Envoy::Http::Protocol OptionsImpl::protocol() const {
   }
 }
 
-
 Envoy::Http::Protocol OptionsImpl::tunnelProtocol() const {
   if (tunnel_protocol_ == Protocol::HTTP2) {
     return Envoy::Http::Protocol::Http2;
@@ -937,18 +936,20 @@ OptionsImpl::OptionsImpl(const nighthawk::client::CommandLineOptions& options) {
   burst_size_ = PROTOBUF_GET_WRAPPED_OR_DEFAULT(options, burst_size, burst_size_);
   address_family_ = PROTOBUF_GET_WRAPPED_OR_DEFAULT(options, address_family, address_family_);
 
-
-  if(options.has_tunnel_options()) {
-    tunnel_protocol_ = PROTOBUF_GET_WRAPPED_OR_DEFAULT(options.tunnel_options(), tunnel_protocol, tunnel_protocol_);
+  if (options.has_tunnel_options()) {
+    tunnel_protocol_ = PROTOBUF_GET_WRAPPED_OR_DEFAULT(options.tunnel_options(), tunnel_protocol,
+                                                       tunnel_protocol_);
     tunnel_uri_ = options.tunnel_options().tunnel_uri();
-    
+
     // we must find an available port for the encap listener
     encap_port_ = GetAvailablePort(/*is_udp=*/protocol_ == Protocol::HTTP3);
-    concurrency_ = PROTOBUF_GET_WRAPPED_OR_DEFAULT(options.tunnel_options(), tunnel_concurrency, tunnel_concurrency_);
+    concurrency_ = PROTOBUF_GET_WRAPPED_OR_DEFAULT(options.tunnel_options(), tunnel_concurrency,
+                                                   tunnel_concurrency_);
 
     if (options.tunnel_options().has_tunnel_http3_protocol_options()) {
       tunnel_http3_protocol_options_.emplace(Http3ProtocolOptions());
-      tunnel_http3_protocol_options_.value().MergeFrom(options.tunnel_options().tunnel_http3_protocol_options());
+      tunnel_http3_protocol_options_.value().MergeFrom(
+          options.tunnel_options().tunnel_http3_protocol_options());
     }
     tunnel_tls_context_->MergeFrom(options.tunnel_options().tunnel_tls_context());
   }

source/client/options_impl.h

@@ -44,9 +44,13 @@ class OptionsImpl : public Options, public Envoy::Logger::Loggable<Envoy::Logger
   std::string tunnelUri() const override { return tunnel_uri_; }
   uint32_t encapPort() const override { return encap_port_; }
   virtual const absl::optional<envoy::extensions::transport_sockets::tls::v3::UpstreamTlsContext>
-  tunnelTlsContext() const override {return tunnel_tls_context_;}
+  tunnelTlsContext() const override {
+    return tunnel_tls_context_;
+  }
   virtual const absl::optional<envoy::config::core::v3::Http3ProtocolOptions>&
-  tunnelHttp3ProtocolOptions() const override{return tunnel_http3_protocol_options_;}
+  tunnelHttp3ProtocolOptions() const override {
+    return tunnel_http3_protocol_options_;
+  }
 
   const absl::optional<envoy::config::core::v3::Http3ProtocolOptions>&
   http3ProtocolOptions() const override {
@@ -156,7 +160,8 @@ class OptionsImpl : public Options, public Envoy::Logger::Loggable<Envoy::Logger
   uint32_t encap_port_{0};
   std::string tunnel_concurrency_;
   absl::optional<envoy::config::core::v3::Http3ProtocolOptions> tunnel_http3_protocol_options_;
-  absl::optional<envoy::extensions::transport_sockets::tls::v3::UpstreamTlsContext> tunnel_tls_context_;
+  absl::optional<envoy::extensions::transport_sockets::tls::v3::UpstreamTlsContext>
+      tunnel_tls_context_;
 
   nighthawk::client::Verbosity::VerbosityOptions verbosity_{nighthawk::client::Verbosity::WARN};
   nighthawk::client::OutputFormat::OutputFormatOptions output_format_{