ci: fix clang tidy after PR 2863

Author: canepat

silkworm/rpc/http/chunker.hpp

@@ -19,7 +19,7 @@ class Chunker {
         current_chunk_.reserve(kDefaultMaxChunkSize);
     }
 
-    ~Chunker() {}
+    ~Chunker() = default;
 
     void queue_data(const std::string& new_buffer) {
         size_t position = 0;

silkworm/rpc/http/connection.cpp

@@ -103,12 +103,12 @@ Task<bool> Connection::do_read() {
     auto gzip_encoding_requested = accept_encoding.contains(kGzipEncoding) && http_compression_;
 
     RequestData request_data{
-        .request_keep_alive_ = parser.get().keep_alive(),
-        .request_http_version_ = parser.get().version(),
-        .gzip_encoding_requested_ = gzip_encoding_requested,
-        .vary_ = req[boost::beast::http::field::vary],
-        .origin_ = req[boost::beast::http::field::origin],
-        .method_ = req.method(),
+        .request_keep_alive = parser.get().keep_alive(),
+        .request_http_version = parser.get().version(),
+        .gzip_encoding_requested = gzip_encoding_requested,
+        .vary = req[boost::beast::http::field::vary],
+        .origin = req[boost::beast::http::field::origin],
+        .method = req.method(),
     };
 
     if (boost::beast::websocket::is_upgrade(parser.get())) {
@@ -153,7 +153,7 @@ Task<void> Connection::handle_request(const RequestWithStringBody& req, RequestD
 }
 
 Task<void> Connection::handle_preflight(const RequestWithStringBody& req, RequestData& request_data) {
-    boost::beast::http::response<boost::beast::http::string_body> res{boost::beast::http::status::no_content, request_data.request_http_version_};
+    boost::beast::http::response<boost::beast::http::string_body> res{boost::beast::http::status::no_content, request_data.request_http_version};
     std::string vary = req[boost::beast::http::field::vary];
 
     if (vary.empty()) {
@@ -193,7 +193,7 @@ Task<void> Connection::handle_actual_request(const RequestWithStringBody& req, R
         co_return;
     }
 
-    if (http_compression_ && !accept_encoding.empty() && !accept_encoding.contains(kIdentity) && !request_data.gzip_encoding_requested_) {
+    if (http_compression_ && !accept_encoding.empty() && !accept_encoding.contains(kIdentity) && !request_data.gzip_encoding_requested) {
         co_await do_write("unsupported requested compression\n", boost::beast::http::status::unsupported_media_type, request_data, kGzipEncoding);
         co_return;
     }
@@ -217,28 +217,25 @@ Task<void> Connection::handle_actual_request(const RequestWithStringBody& req, R
         co_return;
     }
 
-    request_map_.emplace(request_id_, std::move(request_data));
     auto rsp_content = co_await handler_->handle(req.body(), request_id_);
     if (rsp_content) {
-        // no streaming api
-        co_await do_write(rsp_content->append("\n"), boost::beast::http::status::ok, request_data, request_data.gzip_encoding_requested_ ? kGzipEncoding : "", request_data.gzip_encoding_requested_);
-        auto it = request_map_.find(request_id_);
-        if (it != request_map_.end()) {
-            request_map_.erase(it);
-        }
+        // no streaming
+        co_await do_write(rsp_content->append("\n"), boost::beast::http::status::ok, request_data, request_data.gzip_encoding_requested ? kGzipEncoding : "", request_data.gzip_encoding_requested);
+    } else {
+        request_map_.emplace(request_id_, std::move(request_data));
     }
     request_id_++;
 }
 
 //! Write chunked response headers
 Task<void> Connection::create_chunk_header(RequestData& request_data) {
     try {
-        boost::beast::http::response<boost::beast::http::empty_body> rsp{boost::beast::http::status::ok, request_data.request_http_version_};
+        boost::beast::http::response<boost::beast::http::empty_body> rsp{boost::beast::http::status::ok, request_data.request_http_version};
         rsp.set(boost::beast::http::field::content_type, "application/json");
         rsp.set(boost::beast::http::field::date, get_date_time());
         rsp.chunked(true);
 
-        if (request_data.gzip_encoding_requested_) {
+        if (request_data.gzip_encoding_requested) {
             rsp.set(boost::beast::http::field::content_encoding, kGzipEncoding);
         }
 
@@ -266,7 +263,7 @@ Task<void> Connection::open_stream(uint64_t request_id) {
     auto& request_data = request_data_it->second;
 
     // add chunking supports
-    request_data.chunk_ = std::make_unique<Chunker>();
+    request_data.chunk = std::make_unique<Chunker>();
 
     co_return;
 }
@@ -280,17 +277,17 @@ Task<void> Connection::close_stream(uint64_t request_id) {
     auto& request_data = request_data_it->second;
 
     try {
-        // get chunk remainder and flush it
-        auto [chunk, first_chunk] = request_data.chunk_->get_remainder();
+        // Get remianing chunk and flush it
+        auto [chunk, first_chunk] = request_data.chunk->get_remainder();
         if (first_chunk) {
             if (!chunk.empty()) {
-                // it is first chunk so send full msg without chunking
-                co_await do_write(chunk, boost::beast::http::status::ok, request_data, request_data.gzip_encoding_requested_ ? kGzipEncoding : "", /* to_be_compressed */ false);  // data already compressed if nec
+                // If it is the first chunk, send without chunking
+                co_await do_write(chunk, boost::beast::http::status::ok, request_data, request_data.gzip_encoding_requested ? kGzipEncoding : "", /* to_be_compressed */ false);  // data already compressed if nec
             }
         } else {
-            // already a chunk is generated
+            // A previous chunk was already generated
             if (!chunk.empty()) {
-                // send new one
+                // Send the new one
                 co_await send_chunk(chunk);
             }
             co_await boost::asio::async_write(socket_, boost::beast::http::make_chunk_last(), boost::asio::use_awaitable);
@@ -321,19 +318,19 @@ Task<size_t> Connection::write(uint64_t request_id, std::string_view content, bo
         response.append("\n");
     }
 
-    if (request_data.gzip_encoding_requested_) {
+    if (request_data.gzip_encoding_requested) {
         std::string compressed_content;
-        co_await compress(response.data(), compressed_content);
+        co_await compress(response, compressed_content);
         // queued compressed buffer
-        request_data.chunk_->queue_data(std::move(compressed_content));
+        request_data.chunk->queue_data(compressed_content);
     } else {
         // queued clear buffer
-        request_data.chunk_->queue_data(std::move(response));
+        request_data.chunk->queue_data(response);
     }
 
     // until completed chunk are present
-    while (request_data.chunk_->has_chunks()) {
-        auto [complete_chunk, first_chunk] = request_data.chunk_->get_complete_chunk();
+    while (request_data.chunk->has_chunks()) {
+        auto [complete_chunk, first_chunk] = request_data.chunk->get_complete_chunk();
 
         if (first_chunk) {
             co_await create_chunk_header(request_data);
@@ -363,7 +360,7 @@ Task<size_t> Connection::send_chunk(const std::string& content) {
 Task<void> Connection::do_write(const std::string& content, boost::beast::http::status http_status, RequestData& request_data, std::string_view content_encoding, bool to_be_compressed) {
     try {
         SILK_TRACE << "Connection::do_write response: " << http_status << " content: " << content;
-        boost::beast::http::response<boost::beast::http::string_body> res{http_status, request_data.request_http_version_};
+        boost::beast::http::response<boost::beast::http::string_body> res{http_status, request_data.request_http_version};
 
         if (http_status != boost::beast::http::status::ok) {
             res.set(boost::beast::http::field::content_type, "text/plain");
@@ -373,7 +370,7 @@ Task<void> Connection::do_write(const std::string& content, boost::beast::http::
 
         res.set(boost::beast::http::field::date, get_date_time());
         res.erase(boost::beast::http::field::host);
-        res.keep_alive(request_data.request_keep_alive_);
+        res.keep_alive(request_data.request_keep_alive);
         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);
@@ -385,7 +382,7 @@ Task<void> Connection::do_write(const std::string& content, boost::beast::http::
                 res.body() = std::move(compressed_content);
             } else {
                 res.content_length(content.size());
-                res.body() = std::move(content);
+                res.body() = content;
             }
 
         } else {
@@ -394,7 +391,7 @@ Task<void> Connection::do_write(const std::string& content, boost::beast::http::
                 res.set(boost::beast::http::field::accept_encoding, content_encoding);  // Indicate the supported encoding
             }
             res.content_length(content.size());
-            res.body() = std::move(content);
+            res.body() = content;
         }
 
         set_cors<boost::beast::http::string_body>(res, request_data);
@@ -464,29 +461,29 @@ Connection::AuthorizationResult Connection::is_request_authorized(const RequestW
 
 template <class Body>
 void Connection::set_cors(boost::beast::http::response<Body>& res, RequestData& request_data) {
-    if (request_data.vary_.empty()) {
+    if (request_data.vary.empty()) {
         res.set(boost::beast::http::field::vary, "Origin");
     } else {
-        auto vary{request_data.vary_};
+        auto vary{request_data.vary};
         res.set(boost::beast::http::field::vary, vary.append(" Origin"));
     }
 
-    if (request_data.origin_.empty()) {
+    if (request_data.origin.empty()) {
         return;
     }
 
-    if (!is_origin_allowed(allowed_origins_, request_data.origin_)) {
+    if (!is_origin_allowed(allowed_origins_, request_data.origin)) {
         return;
     }
 
-    if (!is_method_allowed(request_data.method_)) {
+    if (!is_method_allowed(request_data.method)) {
         return;
     }
 
     if (allowed_origins_.at(0) == "*") {
         res.set(boost::beast::http::field::access_control_allow_origin, "*");
     } else {
-        res.set(boost::beast::http::field::access_control_allow_origin, request_data.origin_);
+        res.set(boost::beast::http::field::access_control_allow_origin, request_data.origin);
     }
 }
 

silkworm/rpc/http/connection.hpp

@@ -31,13 +31,13 @@ using RequestWithStringBody = boost::beast::http::request<boost::beast::http::st
 inline constexpr size_t kDefaultCapacity = 4 * 1024;
 
 struct RequestData {
-    bool request_keep_alive_{false};
-    unsigned int request_http_version_{11};
-    bool gzip_encoding_requested_{false};
-    std::string vary_;
-    std::string origin_;
-    boost::beast::http::verb method_{boost::beast::http::verb::unknown};
-    std::unique_ptr<Chunker> chunk_;
+    bool request_keep_alive{false};
+    unsigned int request_http_version{11};
+    bool gzip_encoding_requested{false};
+    std::string vary;
+    std::string origin;
+    boost::beast::http::verb method{boost::beast::http::verb::unknown};
+    std::unique_ptr<Chunker> chunk;
 };
 
 //! Represents a single connection from a client.