admin: Remove admin callback url param

.bazelversion

@@ -1 +1 @@
-6.0.0-pre.20220706.4
+5.0.0

envoy/server/admin.h

@@ -72,9 +72,9 @@ class AdminStream {
  * done in the RouteConfigProviderManagerImpl constructor in source/common/router/rds_impl.cc.
  */
 #define MAKE_ADMIN_HANDLER(X)                                                                      \
-  [this](absl::string_view path_and_query, Http::ResponseHeaderMap& response_headers,              \
-         Buffer::Instance& data, Server::AdminStream& admin_stream) -> Http::Code {                \
-    return X(path_and_query, response_headers, data, admin_stream);                                \
+  [this](Http::ResponseHeaderMap& response_headers, Buffer::Instance& data,                        \
+         Server::AdminStream& admin_stream) -> Http::Code {                                        \
+    return X(response_headers, data, admin_stream);                                                \
   }
 
 /**
@@ -152,7 +152,7 @@ class Admin {
   /**
    * Lambda to generate a Request.
    */
-  using GenRequestFn = std::function<RequestPtr(absl::string_view path, AdminStream&)>;
+  using GenRequestFn = std::function<RequestPtr(AdminStream&)>;
 
   /**
    * Individual admin handler including prefix, help text, and callback.
@@ -176,9 +176,9 @@ class Admin {
    * its data.
    * @return Http::Code the response code.
    */
-  using HandlerCb = std::function<Http::Code(
-      absl::string_view path_and_query, Http::ResponseHeaderMap& response_headers,
-      Buffer::Instance& response, AdminStream& admin_stream)>;
+  using HandlerCb =
+      std::function<Http::Code(Http::ResponseHeaderMap& response_headers,
+                               Buffer::Instance& response, AdminStream& admin_stream)>;
 
   /**
    * Add a legacy admin handler where the entire response is written in

source/extensions/common/tap/admin.cc

@@ -42,7 +42,7 @@ AdminHandler::~AdminHandler() {
   ASSERT(rc);
 }
 
-Http::Code AdminHandler::handler(absl::string_view, Http::HeaderMap&, Buffer::Instance& response,
+Http::Code AdminHandler::handler(Http::HeaderMap&, Buffer::Instance& response,
                                  Server::AdminStream& admin_stream) {
   if (attached_request_ != nullptr) {
     // TODO(mattlklein123): Consider supporting concurrent admin /tap streams. Right now we support

source/extensions/common/tap/admin.h

@@ -204,8 +204,8 @@ class AdminHandler : public Singleton::Instance,
     AdminHandler& parent_;
   };
 
-  Http::Code handler(absl::string_view path_and_query, Http::HeaderMap& response_headers,
-                     Buffer::Instance& response, Server::AdminStream& admin_stream);
+  Http::Code handler(Http::HeaderMap& response_headers, Buffer::Instance& response,
+                     Server::AdminStream& admin_stream);
   Http::Code badRequest(Buffer::Instance& response, absl::string_view error);
 
   Server::Admin& admin_;

source/extensions/stat_sinks/hystrix/hystrix.cc

@@ -290,8 +290,7 @@ HystrixSink::HystrixSink(Server::Configuration::ServerFactoryContext& server,
                    MAKE_ADMIN_HANDLER(handlerHystrixEventStream), false, false);
 }
 
-Http::Code HystrixSink::handlerHystrixEventStream(absl::string_view,
-                                                  Http::ResponseHeaderMap& response_headers,
+Http::Code HystrixSink::handlerHystrixEventStream(Http::ResponseHeaderMap& response_headers,
                                                   Buffer::Instance&,
                                                   Server::AdminStream& admin_stream) {
 

source/extensions/stat_sinks/hystrix/hystrix.h

@@ -48,8 +48,8 @@ using ClusterStatsCachePtr = std::unique_ptr<ClusterStatsCache>;
 class HystrixSink : public Stats::Sink, public Logger::Loggable<Logger::Id::hystrix> {
 public:
   HystrixSink(Server::Configuration::ServerFactoryContext& server, uint64_t num_buckets);
-  Http::Code handlerHystrixEventStream(absl::string_view, Http::ResponseHeaderMap& response_headers,
-                                       Buffer::Instance&, Server::AdminStream& admin_stream);
+  Http::Code handlerHystrixEventStream(Http::ResponseHeaderMap& response_headers, Buffer::Instance&,
+                                       Server::AdminStream& admin_stream);
   void flush(Stats::MetricSnapshot& snapshot) override;
   void onHistogramComplete(const Stats::Histogram&, uint64_t) override{};
 

source/server/admin/admin.cc

@@ -295,20 +295,17 @@ class StaticTextRequest : public Admin::Request {
 // generates the entire admin output in one shot.
 class RequestGasket : public Admin::Request {
 public:
-  RequestGasket(Admin::HandlerCb handler_cb, absl::string_view path_and_query,
-                AdminStream& admin_stream)
-      : path_and_query_(std::string(path_and_query)), handler_cb_(handler_cb),
-        admin_stream_(admin_stream) {}
+  RequestGasket(Admin::HandlerCb handler_cb, AdminStream& admin_stream)
+      : handler_cb_(handler_cb), admin_stream_(admin_stream) {}
 
   static Admin::GenRequestFn makeGen(Admin::HandlerCb callback) {
-    return [callback](absl::string_view path_and_query,
-                      AdminStream& admin_stream) -> Server::Admin::RequestPtr {
-      return std::make_unique<RequestGasket>(callback, path_and_query, admin_stream);
+    return [callback](AdminStream& admin_stream) -> Server::Admin::RequestPtr {
+      return std::make_unique<RequestGasket>(callback, admin_stream);
     };
   }
 
   Http::Code start(Http::ResponseHeaderMap& response_headers) override {
-    return handler_cb_(path_and_query_, response_headers, response_, admin_stream_);
+    return handler_cb_(response_headers, response_, admin_stream_);
   }
 
   bool nextChunk(Buffer::Instance& response) override {
@@ -317,7 +314,6 @@ class RequestGasket : public Admin::Request {
   }
 
 private:
-  std::string path_and_query_;
   Admin::HandlerCb handler_cb_;
   AdminStream& admin_stream_;
   Buffer::OwnedImpl response_;
@@ -333,10 +329,9 @@ Admin::RequestPtr Admin::makeStaticTextRequest(Buffer::Instance& response, Http:
   return std::make_unique<StaticTextRequest>(response, code);
 }
 
-Http::Code AdminImpl::runCallback(absl::string_view path_and_query,
-                                  Http::ResponseHeaderMap& response_headers,
+Http::Code AdminImpl::runCallback(Http::ResponseHeaderMap& response_headers,
                                   Buffer::Instance& response, AdminStream& admin_stream) {
-  RequestPtr request = makeRequest(path_and_query, admin_stream);
+  RequestPtr request = makeRequest(admin_stream);
   Http::Code code = request->start(response_headers);
   bool more_data;
   do {
@@ -346,8 +341,8 @@ Http::Code AdminImpl::runCallback(absl::string_view path_and_query,
   return code;
 }
 
-Admin::RequestPtr AdminImpl::makeRequest(absl::string_view path_and_query,
-                                         AdminStream& admin_stream) const {
+Admin::RequestPtr AdminImpl::makeRequest(AdminStream& admin_stream) const {
+  absl::string_view path_and_query = admin_stream.getRequestHeaders().getPathValue();
   std::string::size_type query_index = path_and_query.find('?');
   if (query_index == std::string::npos) {
     query_index = path_and_query.size();
@@ -367,7 +362,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);
+      return handler.handler_(admin_stream);
     }
   }
 
@@ -390,8 +385,8 @@ std::vector<const AdminImpl::UrlHandler*> AdminImpl::sortedHandlers() const {
   return sorted_handlers;
 }
 
-Http::Code AdminImpl::handlerHelp(absl::string_view, Http::ResponseHeaderMap&,
-                                  Buffer::Instance& response, AdminStream&) {
+Http::Code AdminImpl::handlerHelp(Http::ResponseHeaderMap&, Buffer::Instance& response,
+                                  AdminStream&) {
   getHelp(response);
   return Http::Code::OK;
 }
@@ -477,7 +472,7 @@ Http::Code AdminImpl::request(absl::string_view path_and_query, absl::string_vie
   filter.decodeHeaders(*request_headers, false);
   Buffer::OwnedImpl response;
 
-  Http::Code code = runCallback(path_and_query, response_headers, response, filter);
+  Http::Code code = runCallback(response_headers, response, filter);
   Utility::populateFallbackResponseHeaders(code, response_headers);
   body = response.toString();
   return code;

source/server/admin/admin.h

@@ -71,8 +71,7 @@ class AdminImpl : public Admin,
   AdminImpl(const std::string& profile_path, Server::Instance& server,
             bool ignore_global_conn_limit);
 
-  Http::Code runCallback(absl::string_view path_and_query,
-                         Http::ResponseHeaderMap& response_headers, Buffer::Instance& response,
+  Http::Code runCallback(Http::ResponseHeaderMap& response_headers, Buffer::Instance& response,
                          AdminStream& admin_stream);
   const Network::Socket& socket() override { return *socket_; }
   Network::Socket& mutableSocket() { return *socket_; }
@@ -204,9 +203,7 @@ class AdminImpl : public Admin,
   void addListenerToHandler(Network::ConnectionHandler* handler) override;
 
   GenRequestFn createRequestFunction() const {
-    return [this](absl::string_view path_and_query, AdminStream& admin_stream) -> RequestPtr {
-      return makeRequest(path_and_query, admin_stream);
-    };
+    return [this](AdminStream& admin_stream) -> RequestPtr { return makeRequest(admin_stream); };
   }
   uint64_t maxRequestsPerConnection() const override { return 0; }
   const HttpConnectionManagerProto::ProxyStatusConfig* proxyStatusConfig() const override {
@@ -221,9 +218,9 @@ class AdminImpl : public Admin,
   friend class AdminTestingPeer;
 
   /**
-   * Creates a Request from a url.
+   * Creates a Request from the request in the admin stream.
    */
-  RequestPtr makeRequest(absl::string_view path_and_query, AdminStream& admin_stream) const;
+  RequestPtr makeRequest(AdminStream& admin_stream) const;
 
   /**
    * Creates a UrlHandler structure from a non-chunked callback.
@@ -234,7 +231,7 @@ class AdminImpl : public Admin,
 
   /**
    * Creates a URL prefix bound to chunked handler. Handler is expected to
-   * supply a method makeRequest(absl::string_view, AdminStream&).
+   * supply a method makeRequest(AdminStream&).
    *
    * @param prefix the prefix to register
    * @param help_text a help text ot display in a table in the admin home page
@@ -248,8 +245,8 @@ class AdminImpl : public Admin,
   UrlHandler makeStreamingHandler(const std::string& prefix, const std::string& help_text,
                                   Handler& handler, bool removable, bool mutates_state) {
     return {prefix, help_text,
-            [&handler](absl::string_view path, AdminStream& admin_stream) -> Admin::RequestPtr {
-              return handler.makeRequest(path, admin_stream);
+            [&handler](AdminStream& admin_stream) -> Admin::RequestPtr {
+              return handler.makeRequest(admin_stream);
             },
             removable, mutates_state};
   }
@@ -341,12 +338,10 @@ class AdminImpl : public Admin,
   /**
    * URL handlers.
    */
-  Http::Code handlerAdminHome(absl::string_view path_and_query,
-                              Http::ResponseHeaderMap& response_headers, Buffer::Instance& response,
+  Http::Code handlerAdminHome(Http::ResponseHeaderMap& response_headers, Buffer::Instance& response,
                               AdminStream&);
 
-  Http::Code handlerHelp(absl::string_view path_and_query,
-                         Http::ResponseHeaderMap& response_headers, Buffer::Instance& response,
+  Http::Code handlerHelp(Http::ResponseHeaderMap& response_headers, Buffer::Instance& response,
                          AdminStream&);
   void getHelp(Buffer::Instance& response) const;
 

source/server/admin/admin_filter.cc

@@ -86,7 +86,7 @@ void AdminFilter::onComplete() {
 
   auto header_map = Http::ResponseHeaderMapImpl::create();
   RELEASE_ASSERT(request_headers_, "");
-  Admin::RequestPtr handler = admin_handler_fn_(path, *this);
+  Admin::RequestPtr handler = admin_handler_fn_(*this);
   Http::Code code = handler->start(*header_map);
   Utility::populateFallbackResponseHeaders(code, *header_map);
   decoder_callbacks_->encodeHeaders(std::move(header_map), false,

source/server/admin/admin_html.cc

@@ -5,7 +5,7 @@
 namespace Envoy {
 namespace Server {
 
-Http::Code AdminImpl::handlerAdminHome(absl::string_view, Http::ResponseHeaderMap& response_headers,
+Http::Code AdminImpl::handlerAdminHome(Http::ResponseHeaderMap& response_headers,
                                        Buffer::Instance& response, AdminStream&) {
   StatsHtmlRender html(response_headers, response, StatsParams());
   html.tableBegin(response);

source/server/admin/admin_no_html.cc

@@ -3,7 +3,7 @@
 namespace Envoy {
 namespace Server {
 
-Http::Code AdminImpl::handlerAdminHome(absl::string_view, Http::ResponseHeaderMap& response_headers,
+Http::Code AdminImpl::handlerAdminHome(Http::ResponseHeaderMap& response_headers,
                                        Buffer::Instance& response, AdminStream&) {
   response_headers.setReferenceContentType(Http::Headers::get().ContentTypeValues.Text);
   response.add("HTML output was disabled by building with --define=admin_html=disabled");

source/server/admin/clusters_handler.cc

@@ -42,8 +42,7 @@ void addCircuitBreakerSettingsAsJson(const envoy::config::core::v3::RoutingPrior
 
 ClustersHandler::ClustersHandler(Server::Instance& server) : HandlerContextBase(server) {}
 
-Http::Code ClustersHandler::handlerClusters(absl::string_view,
-                                            Http::ResponseHeaderMap& response_headers,
+Http::Code ClustersHandler::handlerClusters(Http::ResponseHeaderMap& response_headers,
                                             Buffer::Instance& response, AdminStream& admin_stream) {
   const auto format_value = Utility::formatParam(admin_stream.queryParams());
 

source/server/admin/clusters_handler.h

@@ -18,8 +18,7 @@ class ClustersHandler : public HandlerContextBase {
 public:
   ClustersHandler(Server::Instance& server);
 
-  Http::Code handlerClusters(absl::string_view path_and_query,
-                             Http::ResponseHeaderMap& response_headers, Buffer::Instance& response,
+  Http::Code handlerClusters(Http::ResponseHeaderMap& response_headers, Buffer::Instance& response,
                              AdminStream&);
 
 private:

source/server/admin/config_dump_handler.cc

@@ -157,8 +157,7 @@ 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,
-                                                Http::ResponseHeaderMap& response_headers,
+Http::Code ConfigDumpHandler::handlerConfigDump(Http::ResponseHeaderMap& response_headers,
                                                 Buffer::Instance& response,
                                                 AdminStream& admin_stream) const {
   Http::Utility::QueryParams query_params = admin_stream.queryParams();

source/server/admin/config_dump_handler.h

@@ -22,8 +22,7 @@ class ConfigDumpHandler : public HandlerContextBase {
 public:
   ConfigDumpHandler(ConfigTracker& config_tracker, Server::Instance& server);
 
-  Http::Code handlerConfigDump(absl::string_view path_and_query,
-                               Http::ResponseHeaderMap& response_headers,
+  Http::Code handlerConfigDump(Http::ResponseHeaderMap& response_headers,
                                Buffer::Instance& response, AdminStream&) const;
 
 private:

source/server/admin/init_dump_handler.cc

@@ -18,8 +18,7 @@ absl::optional<std::string> maskParam(const Http::Utility::QueryParams& params)
 
 InitDumpHandler::InitDumpHandler(Server::Instance& server) : HandlerContextBase(server) {}
 
-Http::Code InitDumpHandler::handlerInitDump(absl::string_view,
-                                            Http::ResponseHeaderMap& response_headers,
+Http::Code InitDumpHandler::handlerInitDump(Http::ResponseHeaderMap& response_headers,
                                             Buffer::Instance& response,
                                             AdminStream& admin_stream) const {
   const auto mask = maskParam(admin_stream.queryParams());

source/server/admin/init_dump_handler.h

@@ -19,8 +19,7 @@ class InitDumpHandler : public HandlerContextBase {
 public:
   InitDumpHandler(Server::Instance& server);
 
-  Http::Code handlerInitDump(absl::string_view path_and_query,
-                             Http::ResponseHeaderMap& response_headers, Buffer::Instance& response,
+  Http::Code handlerInitDump(Http::ResponseHeaderMap& response_headers, Buffer::Instance& response,
                              AdminStream&) const;
 
 private:

source/server/admin/listeners_handler.cc

@@ -12,7 +12,7 @@ namespace Server {
 
 ListenersHandler::ListenersHandler(Server::Instance& server) : HandlerContextBase(server) {}
 
-Http::Code ListenersHandler::handlerDrainListeners(absl::string_view, Http::ResponseHeaderMap&,
+Http::Code ListenersHandler::handlerDrainListeners(Http::ResponseHeaderMap&,
                                                    Buffer::Instance& response,
                                                    AdminStream& admin_query) {
   const Http::Utility::QueryParams params = admin_query.queryParams();
@@ -38,8 +38,7 @@ Http::Code ListenersHandler::handlerDrainListeners(absl::string_view, Http::Resp
   return Http::Code::OK;
 }
 
-Http::Code ListenersHandler::handlerListenerInfo(absl::string_view,
-                                                 Http::ResponseHeaderMap& response_headers,
+Http::Code ListenersHandler::handlerListenerInfo(Http::ResponseHeaderMap& response_headers,
                                                  Buffer::Instance& response,
                                                  AdminStream& admin_query) {
   const Http::Utility::QueryParams query_params = admin_query.queryParams();

source/server/admin/listeners_handler.h

@@ -18,12 +18,10 @@ class ListenersHandler : public HandlerContextBase {
 public:
   ListenersHandler(Server::Instance& server);
 
-  Http::Code handlerDrainListeners(absl::string_view path_and_query,
-                                   Http::ResponseHeaderMap& response_headers,
+  Http::Code handlerDrainListeners(Http::ResponseHeaderMap& response_headers,
                                    Buffer::Instance& response, AdminStream&);
 
-  Http::Code handlerListenerInfo(absl::string_view path_and_query,
-                                 Http::ResponseHeaderMap& response_headers,
+  Http::Code handlerListenerInfo(Http::ResponseHeaderMap& response_headers,
                                  Buffer::Instance& response, AdminStream&);
 
 private:

source/server/admin/logs_handler.cc

@@ -37,8 +37,8 @@ std::vector<absl::string_view> LogsHandler::levelStrings() {
   return strings;
 }
 
-Http::Code LogsHandler::handlerLogging(absl::string_view, Http::ResponseHeaderMap&,
-                                       Buffer::Instance& response, AdminStream& admin_stream) {
+Http::Code LogsHandler::handlerLogging(Http::ResponseHeaderMap&, Buffer::Instance& response,
+                                       AdminStream& admin_stream) {
   Http::Utility::QueryParams query_params = admin_stream.queryParams();
 
   Http::Code rc = Http::Code::OK;
@@ -75,8 +75,8 @@ Http::Code LogsHandler::handlerLogging(absl::string_view, Http::ResponseHeaderMa
   return rc;
 }
 
-Http::Code LogsHandler::handlerReopenLogs(absl::string_view, Http::ResponseHeaderMap&,
-                                          Buffer::Instance& response, AdminStream&) {
+Http::Code LogsHandler::handlerReopenLogs(Http::ResponseHeaderMap&, Buffer::Instance& response,
+                                          AdminStream&) {
   server_.accessLogManager().reopen();
   response.add("OK\n");
   return Http::Code::OK;

source/server/admin/logs_handler.h

@@ -22,12 +22,10 @@ class LogsHandler : public HandlerContextBase, Logger::Loggable<Logger::Id::admi
 public:
   LogsHandler(Server::Instance& server);
 
-  Http::Code handlerLogging(absl::string_view path_and_query,
-                            Http::ResponseHeaderMap& response_headers, Buffer::Instance& response,
+  Http::Code handlerLogging(Http::ResponseHeaderMap& response_headers, Buffer::Instance& response,
                             AdminStream&);
 
-  Http::Code handlerReopenLogs(absl::string_view path_and_query,
-                               Http::ResponseHeaderMap& response_headers,
+  Http::Code handlerReopenLogs(Http::ResponseHeaderMap& response_headers,
                                Buffer::Instance& response, AdminStream&);
 
   /**