refactor(replication): avoid blob restore warnings and clean up byte I/O

Move internal blob path resolution behind datastore_impl so TCP and RDMA
replication restore paths no longer depend on the public ready-checked
datastore::get_blob_file() API.

Also clean up byte-buffer handling in blob send paths to address clang-tidy
warnings without adding extra copies in the hot path.

Co-authored-by: Copilot <copilot@github.com>

Author: umegane

src/limestone/rdma/rdma_socket_io.cpp

@@ -18,7 +18,7 @@
 
 #include <algorithm>
 #include <array>
-#include <cstring>
+#include <iterator>
 #include <vector>
 
 #include "replication/blob_send_utils.h"
@@ -94,15 +94,15 @@ rdma_send_stream_base::buffer_fill_result rdma_socket_io::fill_blob_header_and_f
     if (encoded.size() != blob_header_size) {
         return {false, "encoded blob header size mismatch"};
     }
-    std::memcpy(buffer, encoded.data(), encoded.size());
+    std::copy(encoded.begin(), encoded.end(), buffer);
     auto const payload_capacity = capacity - blob_header_size;
     if (payload_capacity > 0U) {
         // read_blob_chunk() returns only after reading the requested length;
         // otherwise it throws, so bytes_read is intentionally not used here.
         [[maybe_unused]] auto const bytes_read = read_blob_chunk(
             fp,
             path,
-            reinterpret_cast<char*>(buffer + blob_header_size),
+            std::next(buffer, blob_header_size),
             payload_capacity);
     }
     return {true, ""};
@@ -133,7 +133,7 @@ rdma_send_stream_base::buffer_fill_result rdma_socket_io::fill_blob_data_chunk(
     // read_blob_chunk() returns only after reading the requested length;
     // otherwise it throws, so bytes_read is intentionally not used here.
     [[maybe_unused]] auto const bytes_read =
-        read_blob_chunk(fp, path, reinterpret_cast<char*>(buffer), capacity);
+        read_blob_chunk(fp, path, buffer, capacity);
     return {true, ""};
 }
 

src/limestone/replication/blob_send_utils.cpp

@@ -3,6 +3,7 @@
 #include <cerrno>
 #include <cstdio>
 #include <cstring>
+#include <iterator>
 #include <limits>
 
 #include <boost/filesystem.hpp>
@@ -69,11 +70,13 @@ void safe_close_blob_file(FILE* fp, char const* failure_message_prefix) {
 std::size_t read_blob_chunk(
         FILE* fp,
         boost::filesystem::path const& path,
-        char* buffer,
+        std::uint8_t* buffer,
         std::size_t length) {
     std::size_t total_read = 0;
     while (total_read < length) {
-        std::size_t r = std::fread(buffer + total_read, 1, length - total_read, fp);
+        using buffer_offset_type = std::iterator_traits<std::uint8_t*>::difference_type;
+        auto const offset = static_cast<buffer_offset_type>(total_read);
+        std::size_t r = std::fread(std::next(buffer, offset), 1, length - total_read, fp);
         if (r == 0) {
             int ec = errno;
             if (ec == EINTR) {

src/limestone/replication/blob_send_utils.h

@@ -51,7 +51,7 @@ void safe_close_blob_file(FILE* fp, char const* failure_message_prefix);
 [[nodiscard]] std::size_t read_blob_chunk(
     FILE* fp,
     boost::filesystem::path const& path,
-    char* buffer,
+    std::uint8_t* buffer,
     std::size_t length);
 
 } // namespace limestone::replication

src/limestone/replication/blob_socket_io.cpp

@@ -27,11 +27,13 @@ void blob_socket_io::send_blob(const blob_id_type blob_id) {
     send_uint64(blob_id);
     send_uint32(remaining);
 
-    std::vector<char> buffer(blob_buffer_size);
+    std::vector<std::uint8_t> buffer(blob_buffer_size);
     while (remaining > 0) {
         std::size_t chunk = std::min(blob_buffer_size, static_cast<std::size_t>(remaining));
         std::size_t total_read = read_blob_chunk(opened.fp, opened.path, buffer.data(), chunk);
-        get_out_stream().write(buffer.data(), static_cast<std::streamsize>(total_read));
+        get_out_stream().write(
+            reinterpret_cast<char const*>(buffer.data()),  // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+            static_cast<std::streamsize>(total_read));
         remaining -= static_cast<uint32_t>(total_read);
     }
 

test/limestone/replication/blob_send_utils_test.cpp

@@ -99,7 +99,7 @@ TEST_F(blob_send_utils_test, read_blob_chunk_reads_exact_bytes) {
     opened_blob_file opened = open_blob_file_for_send(*datastore_, blob_id);
     ASSERT_NE(opened.fp, nullptr);
 
-    std::vector<char> buffer(6);
+    std::vector<std::uint8_t> buffer(6);
     std::size_t bytes_read = read_blob_chunk(
         opened.fp, opened.path, buffer.data(), buffer.size());
     EXPECT_EQ(bytes_read, buffer.size());
@@ -116,7 +116,7 @@ TEST_F(blob_send_utils_test, read_blob_chunk_throws_on_unexpected_eof) {
     opened_blob_file opened = open_blob_file_for_send(*datastore_, blob_id);
     ASSERT_NE(opened.fp, nullptr);
 
-    std::vector<char> buffer(content.size() + 1);
+    std::vector<std::uint8_t> buffer(content.size() + 1);
     EXPECT_THROW({
         [[maybe_unused]] std::size_t bytes_read =
             read_blob_chunk(opened.fp, opened.path, buffer.data(), buffer.size());