admin: support HTML UI for admin post params

envoy/server/admin.h

@@ -55,6 +55,14 @@ class AdminStream {
    * absl::nullopt.
    */
   virtual Http::Http1StreamEncoderOptionsOptRef http1StreamEncoderOptions() PURE;
+
+  /**
+   * Construct query-param map for the stream, using the URL-specified params,
+   * or the request data if that is url-form-encoded.
+   *
+   * @param The query name/value map.
+   */
+  virtual Http::Utility::QueryParams queryParams() const PURE;
 };
 
 /**
@@ -102,7 +110,7 @@ class Admin {
     enum class Type { Boolean, String, Enum };
     const Type type_;
     const std::string id_;   // HTML form ID and query-param name (JS var name rules).
-    const std::string help_; // Help text rendered into UI.
+    const std::string help_; // Rendered into home-page HTML and /help text.
     std::vector<absl::string_view> enum_choices_{};
   };
   using ParamDescriptorVec = std::vector<ParamDescriptor>;

source/server/admin/admin.cc

@@ -76,6 +76,15 @@ void AdminImpl::startHttpListener(const std::list<AccessLog::InstanceSharedPtr>&
   }
 }
 
+namespace {
+// Prepends an element to an array, modifying it as passed in.
+std::vector<absl::string_view> prepend(const absl::string_view first,
+                                       std::vector<absl::string_view> strings) {
+  strings.insert(strings.begin(), first);
+  return strings;
+}
+} // namespace
+
 AdminImpl::AdminImpl(const std::string& profile_path, Server::Instance& server,
                      bool ignore_global_conn_limit)
     : server_(server),
@@ -122,9 +131,17 @@ AdminImpl::AdminImpl(const std::string& profile_path, Server::Instance& server,
           makeHandler("/contention", "dump current Envoy mutex contention stats (if enabled)",
                       MAKE_ADMIN_HANDLER(stats_handler_.handlerContention), false, false),
           makeHandler("/cpuprofiler", "enable/disable the CPU profiler",
-                      MAKE_ADMIN_HANDLER(profiling_handler_.handlerCpuProfiler), false, true),
+                      MAKE_ADMIN_HANDLER(profiling_handler_.handlerCpuProfiler), false, true,
+                      {{Admin::ParamDescriptor::Type::Enum,
+                        "enable",
+                        "enables the CPU profiler",
+                        {"y", "n"}}}),
           makeHandler("/heapprofiler", "enable/disable the heap profiler",
-                      MAKE_ADMIN_HANDLER(profiling_handler_.handlerHeapProfiler), false, true),
+                      MAKE_ADMIN_HANDLER(profiling_handler_.handlerHeapProfiler), false, true,
+                      {{Admin::ParamDescriptor::Type::Enum,
+                        "enable",
+                        "enable/disable the heap profiler",
+                        {"y", "n"}}}),
           makeHandler("/heap_dump", "dump current Envoy heap (if supported)",
                       MAKE_ADMIN_HANDLER(tcmalloc_profiling_handler_.handlerHeapDump), false,
                       false),
@@ -138,20 +155,34 @@ AdminImpl::AdminImpl(const std::string& profile_path, Server::Instance& server,
                       MAKE_ADMIN_HANDLER(server_info_handler_.handlerHotRestartVersion), false,
                       false),
 
-          // TODO(jmarantz): add support for param-passing through a POST. Browsers send
-          // those params as the post-body rather than query-params and that requires some
-          // re-plumbing through the admin callback API. See also drain_listeners.
+          // The logging "level" parameter, if specified as a non-blank entry,
+          // changes all the logging-paths to that level. So the enum parameter
+          // needs to include a an empty string as the default (first) option.
+          // Thus we prepend an empty string to the logging-levels list.
           makeHandler("/logging", "query/change logging levels",
-                      MAKE_ADMIN_HANDLER(logs_handler_.handlerLogging), false, true),
-
+                      MAKE_ADMIN_HANDLER(logs_handler_.handlerLogging), false, true,
+                      {{Admin::ParamDescriptor::Type::String, "paths",
+                        "Change multiple logging levels by setting to "
+                        "<logger_name1>:<desired_level1>,<logger_name2>:<desired_level2>."},
+                       {Admin::ParamDescriptor::Type::Enum, "level", "desired logging level",
+                        prepend("", LogsHandler::levelStrings())}}),
           makeHandler("/memory", "print current allocation/heap usage",
                       MAKE_ADMIN_HANDLER(server_info_handler_.handlerMemory), false, false),
           makeHandler("/quitquitquit", "exit the server",
                       MAKE_ADMIN_HANDLER(server_cmd_handler_.handlerQuitQuitQuit), false, true),
           makeHandler("/reset_counters", "reset all counters to zero",
                       MAKE_ADMIN_HANDLER(stats_handler_.handlerResetCounters), false, true),
-          makeHandler("/drain_listeners", "drain listeners",
-                      MAKE_ADMIN_HANDLER(listeners_handler_.handlerDrainListeners), false, true),
+          makeHandler(
+              "/drain_listeners", "drain listeners",
+              MAKE_ADMIN_HANDLER(listeners_handler_.handlerDrainListeners), false, true,
+              {{ParamDescriptor::Type::Boolean, "graceful",
+                "When draining listeners, enter a graceful drain period prior to closing "
+                "listeners. This behaviour and duration is configurable via server options "
+                "or CLI"},
+               {ParamDescriptor::Type::Boolean, "inboundonly",
+                "Drains all inbound listeners. traffic_direction field in "
+                "envoy_v3_api_msg_config.listener.v3.Listener is used to determine whether a "
+                "listener is inbound or outbound."}}),
           makeHandler("/server_info", "print server version/status information",
                       MAKE_ADMIN_HANDLER(server_info_handler_.handlerServerInfo), false, false),
           makeHandler("/ready", "print server state, return 200 if LIVE, otherwise return 503",
@@ -335,6 +366,7 @@ Admin::RequestPtr AdminImpl::makeRequest(absl::string_view path_and_query,
         }
       }
 
+      ASSERT(admin_stream.getRequestHeaders().getPathValue() == path_and_query);
       return handler.handler_(path_and_query, admin_stream);
     }
   }
@@ -369,7 +401,8 @@ void AdminImpl::getHelp(Buffer::Instance& response) const {
 
   // Prefix order is used during searching, but for printing do them in alpha order.
   for (const UrlHandler* handler : sortedHandlers()) {
-    response.add(fmt::format("  {}: {}\n", handler->prefix_, handler->help_text_));
+    const absl::string_view method = handler->mutates_server_state_ ? " (POST)" : "";
+    response.add(fmt::format("  {}{}: {}\n", handler->prefix_, method, handler->help_text_));
     for (const ParamDescriptor& param : handler->params_) {
       response.add(fmt::format("      {}: {}", param.id_, param.help_));
       if (param.type_ == ParamDescriptor::Type::Enum) {
@@ -440,6 +473,7 @@ Http::Code AdminImpl::request(absl::string_view path_and_query, absl::string_vie
 
   auto request_headers = Http::RequestHeaderMapImpl::create();
   request_headers->setMethod(method);
+  request_headers->setPath(path_and_query);
   filter.decodeHeaders(*request_headers, false);
   Buffer::OwnedImpl response;
 

source/server/admin/admin_filter.cc

@@ -61,8 +61,27 @@ const Http::RequestHeaderMap& AdminFilter::getRequestHeaders() const {
   return *request_headers_;
 }
 
+Http::Utility::QueryParams AdminFilter::queryParams() const {
+  absl::string_view path = request_headers_->getPathValue();
+  Http::Utility::QueryParams query = Http::Utility::parseAndDecodeQueryString(path);
+  if (!query.empty()) {
+    return query;
+  }
+
+  // Check if the params are in the request's body.
+  if (request_headers_->getContentTypeValue() ==
+      Http::Headers::get().ContentTypeValues.FormUrlEncoded) {
+    const Buffer::Instance* body = getRequestBody();
+    if (body != nullptr) {
+      query = Http::Utility::parseFromBody(body->toString());
+    }
+  }
+
+  return query;
+}
+
 void AdminFilter::onComplete() {
-  const absl::string_view path = request_headers_->getPathValue();
+  absl::string_view path = request_headers_->getPathValue();
   ENVOY_STREAM_LOG(debug, "request complete: path: {}", *decoder_callbacks_, path);
 
   auto header_map = Http::ResponseHeaderMapImpl::create();

source/server/admin/admin_filter.h

@@ -51,6 +51,7 @@ class AdminFilter : public Http::PassThroughFilter,
   Http::Http1StreamEncoderOptionsOptRef http1StreamEncoderOptions() override {
     return encoder_callbacks_->http1StreamEncoderOptions();
   }
+  Http::Utility::QueryParams queryParams() const override;
 
 private:
   /**

source/server/admin/clusters_handler.cc

@@ -42,11 +42,10 @@ void addCircuitBreakerSettingsAsJson(const envoy::config::core::v3::RoutingPrior
 
 ClustersHandler::ClustersHandler(Server::Instance& server) : HandlerContextBase(server) {}
 
-Http::Code ClustersHandler::handlerClusters(absl::string_view url,
+Http::Code ClustersHandler::handlerClusters(absl::string_view,
                                             Http::ResponseHeaderMap& response_headers,
-                                            Buffer::Instance& response, AdminStream&) {
-  Http::Utility::QueryParams query_params = Http::Utility::parseAndDecodeQueryString(url);
-  const auto format_value = Utility::formatParam(query_params);
+                                            Buffer::Instance& response, AdminStream& admin_stream) {
+  const auto format_value = Utility::formatParam(admin_stream.queryParams());
 
   if (format_value.has_value() && format_value.value() == "json") {
     writeClustersAsJson(response);

source/server/admin/config_dump_handler.cc

@@ -131,13 +131,13 @@ absl::optional<std::string> maskParam(const Http::Utility::QueryParams& params)
 
 // Helper method to get the eds parameter.
 bool shouldIncludeEdsInDump(const Http::Utility::QueryParams& params) {
-  return Utility::queryParam(params, "include_eds") != absl::nullopt;
+  return params.find("include_eds") != params.end();
 }
 
 absl::StatusOr<Matchers::StringMatcherPtr>
 buildNameMatcher(const Http::Utility::QueryParams& params) {
   const auto name_regex = Utility::queryParam(params, "name_regex");
-  if (!name_regex.has_value()) {
+  if (!name_regex.has_value() || name_regex->empty()) {
     return std::make_unique<Matchers::UniversalStringMatcher>();
   }
   envoy::type::matcher::v3::RegexMatcher matcher;
@@ -157,10 +157,11 @@ buildNameMatcher(const Http::Utility::QueryParams& params) {
 ConfigDumpHandler::ConfigDumpHandler(ConfigTracker& config_tracker, Server::Instance& server)
     : HandlerContextBase(server), config_tracker_(config_tracker) {}
 
-Http::Code ConfigDumpHandler::handlerConfigDump(absl::string_view url,
+Http::Code ConfigDumpHandler::handlerConfigDump(absl::string_view,
                                                 Http::ResponseHeaderMap& response_headers,
-                                                Buffer::Instance& response, AdminStream&) const {
-  Http::Utility::QueryParams query_params = Http::Utility::parseAndDecodeQueryString(url);
+                                                Buffer::Instance& response,
+                                                AdminStream& admin_stream) const {
+  Http::Utility::QueryParams query_params = admin_stream.queryParams();
   const auto resource = resourceParam(query_params);
   const auto mask = maskParam(query_params);
   const bool include_eds = shouldIncludeEdsInDump(query_params);

source/server/admin/init_dump_handler.cc

@@ -18,11 +18,11 @@ absl::optional<std::string> maskParam(const Http::Utility::QueryParams& params)
 
 InitDumpHandler::InitDumpHandler(Server::Instance& server) : HandlerContextBase(server) {}
 
-Http::Code InitDumpHandler::handlerInitDump(absl::string_view url,
+Http::Code InitDumpHandler::handlerInitDump(absl::string_view,
                                             Http::ResponseHeaderMap& response_headers,
-                                            Buffer::Instance& response, AdminStream&) const {
-  Http::Utility::QueryParams query_params = Http::Utility::parseAndDecodeQueryString(url);
-  const auto mask = maskParam(query_params);
+                                            Buffer::Instance& response,
+                                            AdminStream& admin_stream) const {
+  const auto mask = maskParam(admin_stream.queryParams());
 
   envoy::admin::v3::UnreadyTargetsDumps dump = *dumpUnreadyTargets(mask);
   MessageUtil::redact(dump);

source/server/admin/listeners_handler.cc

@@ -12,9 +12,10 @@ namespace Server {
 
 ListenersHandler::ListenersHandler(Server::Instance& server) : HandlerContextBase(server) {}
 
-Http::Code ListenersHandler::handlerDrainListeners(absl::string_view url, Http::ResponseHeaderMap&,
-                                                   Buffer::Instance& response, AdminStream&) {
-  const Http::Utility::QueryParams params = Http::Utility::parseQueryString(url);
+Http::Code ListenersHandler::handlerDrainListeners(absl::string_view, Http::ResponseHeaderMap&,
+                                                   Buffer::Instance& response,
+                                                   AdminStream& admin_query) {
+  const Http::Utility::QueryParams params = admin_query.queryParams();
 
   ListenerManager::StopListenersType stop_listeners_type =
       params.find("inboundonly") != params.end() ? ListenerManager::StopListenersType::InboundOnly
@@ -37,10 +38,11 @@ Http::Code ListenersHandler::handlerDrainListeners(absl::string_view url, Http::
   return Http::Code::OK;
 }
 
-Http::Code ListenersHandler::handlerListenerInfo(absl::string_view url,
+Http::Code ListenersHandler::handlerListenerInfo(absl::string_view,
                                                  Http::ResponseHeaderMap& response_headers,
-                                                 Buffer::Instance& response, AdminStream&) {
-  const Http::Utility::QueryParams query_params = Http::Utility::parseQueryString(url);
+                                                 Buffer::Instance& response,
+                                                 AdminStream& admin_query) {
+  const Http::Utility::QueryParams query_params = admin_query.queryParams();
   const auto format_value = Utility::formatParam(query_params);
 
   if (format_value.has_value() && format_value.value() == "json") {