#include "common/serializer/buffered_file.h" #include #include #include "common/assert.h" #include "common/exception/runtime.h" #include "common/file_system/file_info.h" #include "common/system_config.h" #include namespace lbug { namespace common { static constexpr uint64_t BUFFER_SIZE = LBUG_PAGE_SIZE; BufferedFileWriter::BufferedFileWriter(FileInfo& fileInfo) : buffer(std::make_unique(BUFFER_SIZE)), fileOffset(0), bufferOffset(0), fileInfo(fileInfo) {} BufferedFileWriter::~BufferedFileWriter() { flush(); } void BufferedFileWriter::write(const uint8_t* data, uint64_t size) { if (size > BUFFER_SIZE) { flush(); fileInfo.writeFile(data, size, fileOffset); fileOffset += size; return; } DASSERT(size <= BUFFER_SIZE); if (bufferOffset + size <= BUFFER_SIZE) { memcpy(&buffer[bufferOffset], data, size); bufferOffset += size; } else { auto toCopy = BUFFER_SIZE - bufferOffset; memcpy(&buffer[bufferOffset], data, toCopy); bufferOffset += toCopy; flush(); auto remaining = size - toCopy; memcpy(buffer.get(), data + toCopy, remaining); bufferOffset += remaining; } } void BufferedFileWriter::clear() { fileInfo.truncate(0); resetOffsets(); } void BufferedFileWriter::flush() { if (bufferOffset == 0) { return; } fileInfo.writeFile(buffer.get(), bufferOffset, fileOffset); fileOffset += bufferOffset; bufferOffset = 0; memset(buffer.get(), 0, BUFFER_SIZE); } void BufferedFileWriter::sync() { fileInfo.syncFile(); } uint64_t BufferedFileWriter::getSize() const { return fileInfo.getFileSize() + bufferOffset; } BufferedFileReader::BufferedFileReader(FileInfo& fileInfo) : buffer(std::make_unique(BUFFER_SIZE)), fileOffset(0), bufferOffset(0), fileInfo(fileInfo), bufferSize{0} { fileSize = this->fileInfo.getFileSize(); readNextPage(); } void BufferedFileReader::read(uint8_t* data, uint64_t size) { if (size > BUFFER_SIZE) { // Clear read buffer. fileOffset -= bufferSize; fileOffset += bufferOffset; bufferOffset = 0; bufferSize = 0; // readFromFile silently short-reads at EOF, so check the range first and throw a // catchable error instead of returning uninitialized bytes. A torn WAL tail (e.g. a // crash or ENOSPC mid-commit) must surface as a replay failure, not a native crash. if (fileOffset > fileSize || size > fileSize - fileOffset) { throw RuntimeException( std::format("Reading past the end of the file {} with size {} at offset {}", fileInfo.path, fileSize, fileOffset)); } fileInfo.readFromFile(data, size, fileOffset); fileOffset += size; } else { // Loop across page boundaries: the final page of a torn file may hold fewer bytes // than requested, and copying the full remainder would overrun the heap buffer. while (size > 0) { if (bufferOffset >= bufferSize) { readNextPage(); } const auto toCopy = std::min(size, bufferSize - bufferOffset); memcpy(data, &buffer[bufferOffset], toCopy); bufferOffset += toCopy; data += toCopy; size -= toCopy; } } } bool BufferedFileReader::finished() { return bufferOffset >= bufferSize && fileSize <= fileOffset; } void BufferedFileReader::readNextPage() { if (fileSize <= fileOffset) { throw RuntimeException( std::format("Reading past the end of the file {} with size {} at offset {}", fileInfo.path, fileSize, fileOffset)); } bufferSize = std::min(fileSize - fileOffset, BUFFER_SIZE); fileInfo.readFromFile(buffer.get(), bufferSize, fileOffset); fileOffset += bufferSize; bufferOffset = 0; } } // namespace common } // namespace lbug