Adding streaming response to AdminClusters endpoint

envoy/http/BUILD

@@ -165,6 +165,7 @@ envoy_cc_library(
     name = "query_params_interface",
     hdrs = ["query_params.h"],
     external_deps = ["abseil_btree"],
+    deps = [":header_map_interface"],
 )
 
 envoy_cc_library(

envoy/server/admin.h

@@ -77,6 +77,16 @@ class AdminStream {
     return X(response_headers, data, admin_stream);                                                \
   }
 
+/**
+ * This macro is used to add streaming handlers to the Admin HTTP Endpoint. It builds
+ * a callback that executes X when the specified admin handler is hit. Member
+ * functions must be called when referenced, so this macro DRYs up the process of
+ * passing member functions to route-handling configuration within
+ * Envoy::Server::AdminImpl.
+ */
+#define MAKE_STREAMING_HANDLER(X)                                                                  \
+  [this](AdminStream& admin_stream) -> Admin::RequestPtr { return X(admin_stream); }
+
 /**
  * Global admin HTTP endpoint for the server, holding a map from URL prefixes to
  * handlers. When an HTTP request arrives at the admin port, the URL is linearly

source/server/admin/BUILD

@@ -336,13 +336,16 @@ envoy_cc_library(
     deps = [
         ":handler_ctx_lib",
         ":utils_lib",
+        "//envoy/buffer:buffer_interface",
         "//envoy/http:codes_interface",
         "//envoy/server:admin_interface",
         "//envoy/server:instance_interface",
         "//source/common/buffer:buffer_lib",
         "//source/common/http:codes_lib",
         "//source/common/http:header_map_lib",
         "//source/common/upstream:host_utility_lib",
+        "//source/server/admin:clusters_params_lib",
+        "//source/server/admin:clusters_request_lib",
         "@envoy_api//envoy/admin/v3:pkg_cc_proto",
     ],
 )
@@ -410,3 +413,38 @@ envoy_cc_library(
         "//source/common/common:macros",
     ],
 )
+
+envoy_cc_library(
+    name = "clusters_request_lib",
+    srcs = ["clusters_request.cc"],
+    hdrs = ["clusters_request.h"],
+    deps = [
+        ":clusters_params_lib",
+        "//envoy/buffer:buffer_interface",
+        "//envoy/http:codes_interface",
+        "//envoy/http:header_map_interface",
+        "//envoy/server:admin_interface",
+        "//envoy/server:instance_interface",
+        "//source/common/buffer:buffer_lib",
+        "//source/common/common:logger_lib",
+        "//source/common/http:headers_lib",
+        "//source/common/json:json_streamer_lib",
+        "//source/common/upstream:host_utility_lib",
+        "@envoy_api//envoy/admin/v3:pkg_cc_proto",
+    ],
+)
+
+envoy_cc_library(
+    name = "clusters_params_lib",
+    srcs = ["clusters_params.cc"],
+    hdrs = ["clusters_params.h"],
+    external_deps = [
+        "abseil_optional",
+        "abseil_strings",
+    ],
+    deps = [
+        "//envoy/buffer:buffer_interface",
+        "//envoy/http:codes_interface",
+        "//envoy/http:query_params_interface",
+    ],
+)

source/server/admin/admin.cc

@@ -9,6 +9,7 @@
 
 #include "envoy/extensions/http/header_validators/envoy_default/v3/header_validator.pb.h"
 #include "envoy/http/header_validator_factory.h"
+#include "envoy/server/admin.h"
 #include "envoy/server/hot_restart.h"
 #include "envoy/server/instance.h"
 #include "envoy/server/options.h"
@@ -123,12 +124,13 @@ AdminImpl::AdminImpl(const std::string& profile_path, Server::Instance& server,
       runtime_handler_(server), listeners_handler_(server), server_cmd_handler_(server),
       server_info_handler_(server),
       // TODO(jsedgwick) add /runtime_reset endpoint that removes all admin-set values
+      // TODO(demitriswan) When C++20 is supported we might want to use designated initialization
+      // for readability.
       handlers_{
           makeHandler("/", "Admin home page", MAKE_ADMIN_HANDLER(handlerAdminHome), false, false),
           makeHandler("/certs", "print certs on machine",
                       MAKE_ADMIN_HANDLER(server_info_handler_.handlerCerts), false, false),
-          makeHandler("/clusters", "upstream cluster status",
-                      MAKE_ADMIN_HANDLER(clusters_handler_.handlerClusters), false, false),
+          clusters_handler_.urlHandler(),
           makeHandler(
               "/config_dump", "dump current Envoy configs (experimental)",
               MAKE_ADMIN_HANDLER(config_dump_handler_.handlerConfigDump), false, false,

source/server/admin/clusters_handler.cc

@@ -1,11 +1,16 @@
 #include "source/server/admin/clusters_handler.h"
 
 #include "envoy/admin/v3/clusters.pb.h"
+#include "envoy/server/admin.h"
 
+#include "source/common/buffer/buffer_impl.h"
+#include "source/common/common/macros.h"
 #include "source/common/http/headers.h"
 #include "source/common/http/utility.h"
 #include "source/common/network/utility.h"
 #include "source/common/upstream/host_utility.h"
+#include "source/server/admin/clusters_params.h"
+#include "source/server/admin/clusters_request.h"
 #include "source/server/admin/utils.h"
 
 namespace Envoy {
@@ -40,6 +45,25 @@ void addCircuitBreakerSettingsAsJson(const envoy::config::core::v3::RoutingPrior
 
 } // namespace
 
+Admin::UrlHandler ClustersHandler::urlHandler() {
+  return {
+      /* prefix =*/"/clusters",
+      /* help_text =*/"upstream clusters status",
+      /* handler =*/MAKE_STREAMING_HANDLER(makeRequest),
+      /* removable =*/false,
+      /* mutates_server_state =*/false,
+      /* params =*/
+      {
+          {
+              /* type =*/Admin::ParamDescriptor::Type::Enum,
+              /* id =*/"format",
+              /* help =*/"The output format",
+              /* enum_choices =*/{"text", "json"},
+          },
+      },
+  };
+}
+
 ClustersHandler::ClustersHandler(Server::Instance& server) : HandlerContextBase(server) {}
 
 Http::Code ClustersHandler::handlerClusters(Http::ResponseHeaderMap& response_headers,
@@ -56,6 +80,28 @@ Http::Code ClustersHandler::handlerClusters(Http::ResponseHeaderMap& response_he
   return Http::Code::OK;
 }
 
+Admin::RequestPtr ClustersHandler::makeRequest(AdminStream& admin_stream) {
+  Buffer::OwnedImpl response;
+  ClustersParams params;
+  Http::Code code = params.parse(admin_stream.getRequestHeaders().getPathValue(), response);
+  if (code != Http::Code::OK) {
+    return Admin::makeStaticTextRequest(response, code);
+  }
+  Admin::RequestPtr request{nullptr};
+  switch (params.format_) {
+  case ClustersParams::Format::Text:
+    request =
+        std::make_unique<TextClustersRequest>(ClustersRequest::DefaultChunkLimit, server_, params);
+    break;
+  case ClustersParams::Format::Json:
+    request =
+        std::make_unique<JsonClustersRequest>(ClustersRequest::DefaultChunkLimit, server_, params);
+    break;
+  }
+  ASSERT(request != nullptr);
+  return request;
+}
+
 // Helper method that ensures that we've setting flags based on all the health flag values on the
 // host.
 void setHealthFlag(Upstream::Host::HealthFlag flag, const Upstream::Host& host,

source/server/admin/clusters_handler.h

@@ -31,6 +31,10 @@ class ClustersHandler : public HandlerContextBase {
 
   Http::Code handlerClusters(Http::ResponseHeaderMap& response_headers, Buffer::Instance& response,
                              AdminStream&);
+  // Returns a RequestPtr implementation suitable for streaming its response.
+  Admin::RequestPtr makeRequest(AdminStream& admin_stream);
+  // Returns a UrlHandler suitable for AdminImpl.
+  Admin::UrlHandler urlHandler();
 
 private:
   void addOutlierInfo(const std::string& cluster_name,

source/server/admin/clusters_params.cc

@@ -0,0 +1,30 @@
+#include "source/server/admin/clusters_params.h"
+
+#include "envoy/http/codes.h"
+#include "envoy/http/query_params.h"
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+namespace Envoy {
+namespace Server {
+
+Http::Code ClustersParams::parse(absl::string_view url, Buffer::Instance& response) {
+  Http::Utility::QueryParamsMulti query =
+      Http::Utility::QueryParamsMulti::parseAndDecodeQueryString(url);
+  absl::optional<std::string> optional_format = query.getFirstValue("format");
+  if (optional_format.has_value()) {
+    if (*optional_format == "json") {
+      format_ = Format::Json;
+    } else if (*optional_format == "text") {
+      format_ = Format::Text;
+    } else {
+      response.addFragments({"invalid format ", *optional_format});
+      return Http::Code::BadRequest;
+    }
+  }
+  return Http::Code::OK;
+}
+
+} // namespace Server
+} // namespace Envoy

source/server/admin/clusters_params.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "envoy/buffer/buffer.h"
+#include "envoy/http/codes.h"
+
+#include "absl/strings/string_view.h"
+
+namespace Envoy {
+namespace Server {
+
+struct ClustersParams {
+  enum class Format {
+    Text,
+    Json,
+  };
+
+  Http::Code parse(absl::string_view url, Buffer::Instance& response);
+
+  Format format_{Format::Text};
+};
+
+} // namespace Server
+} // namespace Envoy