rpcdaemon: simplify HTTP gzip compression handling (#1923)

rpc: fix Clang Tidy after 1914

Author: canepat

silkworm/rpc/http/connection.cpp

@@ -16,10 +16,6 @@
 
 #include "connection.hpp"
 
-#ifndef ZLIB_CONST
-#define ZLIB_CONST
-#endif
-
 #include <array>
 #include <exception>
 #include <string_view>
@@ -44,7 +40,7 @@ namespace silkworm::rpc::http {
 static constexpr std::string_view kMaxAge{"600"};
 static constexpr auto kMaxPayloadSize{30 * kMebi};  // 30MiB
 static constexpr std::array kAcceptedContentTypes{"application/json", "application/jsonrequest", "application/json-rpc"};
-static std::vector<std::string> kSupportedCompressionList{"gzip"};  // specify the compression algo in priority level
+static constexpr auto kGzipEncoding{"gzip"};
 
 Connection::Connection(boost::asio::io_context& io_context,
                        commands::RpcApi& api,
@@ -183,23 +179,10 @@ Task<void> Connection::handle_actual_request(const boost::beast::http::request<b
         co_return;
     }
 
-    std::string selected_compression = "";
-    if (http_compression_ && !accept_encoding.empty()) {
-        selected_compression = select_compression_algo(accept_encoding);
-        if (selected_compression.empty()) {
-            std::string complete_list;
-            bool first = true;
-            for (std::string curr_compression : kSupportedCompressionList) {
-                if (first) {
-                    first = false;
-                } else {
-                    complete_list += ", ";
-                }
-                complete_list += curr_compression;
-            }
-            co_await do_write("unsupported requested compression\n", boost::beast::http::status::unsupported_media_type, complete_list);
-            co_return;
-        }
+    const bool gzip_encoding_requested{accept_encoding.contains(kGzipEncoding)};
+    if (http_compression_ && !accept_encoding.empty() && !gzip_encoding_requested) {
+        co_await do_write("unsupported requested compression\n", boost::beast::http::status::unsupported_media_type, kGzipEncoding);
+        co_return;
     }
 
     if (!is_method_allowed(req.method())) {
@@ -231,7 +214,7 @@ Task<void> Connection::handle_actual_request(const boost::beast::http::request<b
 
     auto rsp_content = co_await request_handler_.handle(req.body());
     if (rsp_content) {
-        co_await do_write(rsp_content->append("\n"), boost::beast::http::status::ok, selected_compression);
+        co_await do_write(rsp_content->append("\n"), boost::beast::http::status::ok, gzip_encoding_requested ? kGzipEncoding : "");
     }
 }
 
@@ -306,15 +289,15 @@ Task<void> Connection::do_write(const std::string& content, boost::beast::http::
         if (http_status == boost::beast::http::status::ok && !content_encoding.empty()) {
             // Positive response w/ compression required
             res.set(boost::beast::http::field::content_encoding, content_encoding);
-            std::string compressed_data;
+            std::string compressed_content;
             try {
-                compress_data(content, compressed_data);
+                compress(content, compressed_content);
             } catch (const std::exception& e) {
                 SILK_ERROR << "Connection::do_write cannot compress exception: " << e.what();
                 throw;
             }
-            res.content_length(compressed_data.length());
-            res.body() = std::move(compressed_data);
+            res.content_length(compressed_content.length());
+            res.body() = std::move(compressed_content);
         } else {
             // Any negative response or positive response w/o compression
             if (!content_encoding.empty()) {
@@ -340,7 +323,7 @@ Task<void> Connection::do_write(const std::string& content, boost::beast::http::
     co_return;
 }
 
-void Connection::compress_data(const std::string& clear_data, std::string& compressed_data) {
+void Connection::compress(const std::string& clear_data, std::string& compressed_data) {
     boost::iostreams::filtering_ostream out;
     out.push(boost::iostreams::gzip_compressor());
     out.push(boost::iostreams::back_inserter(compressed_data));
@@ -415,15 +398,6 @@ void Connection::set_cors(boost::beast::http::response<Body>& res) {
     }
 }
 
-std::string Connection::select_compression_algo(const std::string& requested_compression) {
-    for (std::string curr_compression : kSupportedCompressionList) {
-        if (requested_compression.find(curr_compression) != std::string::npos) {
-            return curr_compression;
-        }
-    }
-    return "";
-}
-
 bool Connection::is_origin_allowed(const std::vector<std::string>& allowed_origins, const std::string& origin) {
     if (allowed_origins.size() == 1 && allowed_origins[0] == "*") {
         return true;

silkworm/rpc/http/connection.hpp

@@ -91,9 +91,7 @@ class Connection : public StreamWriter {
 
     static std::string get_date_time();
 
-    std::string select_compression_algo(const std::string& request_compression);
-
-    void compress_data(const std::string& clear_data, std::string& compressed_data);
+    void compress(const std::string& clear_data, std::string& compressed_data);
 
     //! Socket for the connection.
     boost::asio::ip::tcp::socket socket_;