move WriteToTempFile to basicfile.h (#283)

add helper constructors to BasicFile

3 files changed, 111 insertions, 63 deletions

diff --git a/src/zencore/basicfile.cpp b/src/zencore/basicfile.cpp
index c2a21ae90..b3bffd34d 100644
--- a/src/zencore/basicfile.cpp
+++ b/src/zencore/basicfile.cpp
@@ -28,6 +28,20 @@ BasicFile::~BasicFile()
 {
 	Close();
 }
+BasicFile::BasicFile(const std::filesystem::path& FileName, Mode Mode)
+{
+	Open(FileName, Mode);
+}
+
+BasicFile::BasicFile(const std::filesystem::path& FileName, Mode Mode, std::error_code& Ec)
+{
+	Open(FileName, Mode, Ec);
+}
+
+BasicFile::BasicFile(const std::filesystem::path& FileName, Mode Mode, std::function<bool(std::error_code& Ec)>&& RetryCallback)
+{
+	Open(FileName, Mode, std::move(RetryCallback));
+}
 
 void
 BasicFile::Open(const std::filesystem::path& FileName, Mode Mode)
@@ -267,7 +281,7 @@ BasicFile::StreamByteRange(uint64_t FileOffset, uint64_t Size, std::function<voi
 }
 
 uint64_t
-BasicFile::Write(CompositeBuffer Data, uint64_t FileOffset, std::error_code& Ec)
+BasicFile::Write(const CompositeBuffer& Data, uint64_t FileOffset, std::error_code& Ec)
 {
 	uint64_t WrittenBytes = 0;
 	for (const SharedBuffer& Buffer : Data.GetSegments())
@@ -575,7 +589,6 @@ TemporaryFile::MoveTemporaryIntoPlace(std::filesystem::path FinalFileName, std::
 void
 TemporaryFile::SafeWriteFile(const std::filesystem::path& Path, MemoryView Data)
 {
-	TemporaryFile	TempFile;
 	std::error_code Ec;
 	SafeWriteFile(Path, Data, Ec);
 	if (Ec)
@@ -817,6 +830,53 @@ BasicFileWriter::Flush()
 	m_Base.Write(m_Buffer, BufferedBytes, WriteOffset);
 }
 
+IoBuffer
+WriteToTempFile(CompositeBuffer&& Buffer, const std::filesystem::path& Path, std::function<bool(std::error_code& Ec)>&& RetryCallback)
+{
+	if (std::filesystem::is_regular_file(Path))
+	{
+		IoBuffer ExistingTempFile = IoBuffer(IoBufferBuilder::MakeFromFile(Path));
+		if (ExistingTempFile && ExistingTempFile.GetSize() == Buffer.GetSize())
+		{
+			ExistingTempFile.SetDeleteOnClose(true);
+			return ExistingTempFile;
+		}
+	}
+	BasicFile BlockFile;
+	BlockFile.Open(Path, BasicFile::Mode::kTruncateDelete, std::move(RetryCallback));
+	uint64_t Offset = 0;
+	{
+		static const uint64_t BufferingSize = 256u * 1024u;
+		BasicFileWriter		  BufferedOutput(BlockFile, BufferingSize / 2);
+		for (const SharedBuffer& Segment : Buffer.GetSegments())
+		{
+			size_t SegmentSize = Segment.GetSize();
+
+			IoBufferFileReference FileRef;
+			if (SegmentSize >= (BufferingSize + BufferingSize / 2) && Segment.GetFileReference(FileRef))
+			{
+				ScanFile(FileRef.FileHandle,
+						 FileRef.FileChunkOffset,
+						 FileRef.FileChunkSize,
+						 BufferingSize,
+						 [&BufferedOutput, &Offset](const void* Data, size_t Size) {
+							 BufferedOutput.Write(Data, Size, Offset);
+							 Offset += Size;
+						 });
+			}
+			else
+			{
+				BufferedOutput.Write(Segment.GetData(), SegmentSize, Offset);
+				Offset += SegmentSize;
+			}
+		}
+	}
+	void*	 FileHandle	 = BlockFile.Detach();
+	IoBuffer BlockBuffer = IoBuffer(IoBuffer::File, FileHandle, 0, Offset, /*IsWholeFile*/ true);
+	BlockBuffer.SetDeleteOnClose(true);
+	return BlockBuffer;
+}
+
 //////////////////////////////////////////////////////////////////////////
 
 /*
diff --git a/src/zencore/include/zencore/basicfile.h b/src/zencore/include/zencore/basicfile.h
index 03c5605df..7edd40c9c 100644
--- a/src/zencore/include/zencore/basicfile.h
+++ b/src/zencore/include/zencore/basicfile.h
@@ -46,6 +46,10 @@ public:
 		kPreventWrite  = 0x2000'0000,  // Do not open with write sharing mode (prevent other processes from writing to file while open)
 	};
 
+	BasicFile(const std::filesystem::path& FileName, Mode Mode);
+	BasicFile(const std::filesystem::path& FileName, Mode Mode, std::error_code& Ec);
+	BasicFile(const std::filesystem::path& FileName, Mode Mode, std::function<bool(std::error_code& Ec)>&& RetryCallback);
+
 	void	 Open(const std::filesystem::path& FileName, Mode Mode);
 	void	 Open(const std::filesystem::path& FileName, Mode Mode, std::error_code& Ec);
 	void	 Open(const std::filesystem::path& FileName, Mode Mode, std::function<bool(std::error_code& Ec)>&& RetryCallback);
@@ -56,7 +60,7 @@ public:
 	void	 StreamByteRange(uint64_t FileOffset, uint64_t Size, std::function<void(const void* Data, uint64_t Size)>&& ChunkFun);
 	void	 Write(MemoryView Data, uint64_t FileOffset);
 	void	 Write(MemoryView Data, uint64_t FileOffset, std::error_code& Ec);
-	uint64_t Write(CompositeBuffer Data, uint64_t FileOffset, std::error_code& Ec);
+	uint64_t Write(const CompositeBuffer& Data, uint64_t FileOffset, std::error_code& Ec);
 	void	 Write(const void* Data, uint64_t Size, uint64_t FileOffset);
 	void	 Write(const void* Data, uint64_t Size, uint64_t FileOffset, std::error_code& Ec);
 	void	 Flush();
@@ -180,6 +184,10 @@ private:
 	uint64_t	   m_BufferEnd;
 };
 
+IoBuffer WriteToTempFile(CompositeBuffer&&							Buffer,
+						 const std::filesystem::path&				Path,
+						 std::function<bool(std::error_code& Ec)>&& RetryCallback);
+
 ZENCORE_API void basicfile_forcelink();
 
 }  // namespace zen
diff --git a/src/zenserver/projectstore/remoteprojectstore.cpp b/src/zenserver/projectstore/remoteprojectstore.cpp
index 5b75a840e..0285cc22f 100644
--- a/src/zenserver/projectstore/remoteprojectstore.cpp
+++ b/src/zenserver/projectstore/remoteprojectstore.cpp
@@ -154,63 +154,6 @@ namespace remotestore_impl {
 		return BlockIndex;
 	}
 
-	IoBuffer WriteToTempFile(CompressedBuffer&& CompressedBuffer, std::filesystem::path Path)
-	{
-		if (std::filesystem::is_regular_file(Path))
-		{
-			IoBuffer ExistingTempFile = IoBuffer(IoBufferBuilder::MakeFromFile(Path));
-			if (ExistingTempFile && ExistingTempFile.GetSize() == CompressedBuffer.GetCompressedSize())
-			{
-				ExistingTempFile.SetDeleteOnClose(true);
-				return ExistingTempFile;
-			}
-		}
-		IoBuffer  BlockBuffer;
-		BasicFile BlockFile;
-		uint32_t  RetriesLeft = 3;
-		BlockFile.Open(Path, BasicFile::Mode::kTruncateDelete, [&](std::error_code& Ec) {
-			if (RetriesLeft == 0)
-			{
-				return false;
-			}
-			ZEN_WARN("Failed to create temporary oplog block '{}': '{}', retries left: {}.", Path, Ec.message(), RetriesLeft);
-			Sleep(100 - (3 - RetriesLeft) * 100);  // Total 600 ms
-			RetriesLeft--;
-			return true;
-		});
-		uint64_t Offset = 0;
-		{
-			CompositeBuffer Compressed = std::move(CompressedBuffer).GetCompressed();
-			for (const SharedBuffer& Segment : Compressed.GetSegments())
-			{
-				size_t				  SegmentSize	= Segment.GetSize();
-				static const uint64_t BufferingSize = 256u * 1024u;
-
-				IoBufferFileReference FileRef;
-				if (SegmentSize >= (BufferingSize + BufferingSize / 2) && Segment.GetFileReference(FileRef))
-				{
-					ScanFile(FileRef.FileHandle,
-							 FileRef.FileChunkOffset,
-							 FileRef.FileChunkSize,
-							 BufferingSize,
-							 [&BlockFile, &Offset](const void* Data, size_t Size) {
-								 BlockFile.Write(Data, Size, Offset);
-								 Offset += Size;
-							 });
-				}
-				else
-				{
-					BlockFile.Write(Segment.GetData(), SegmentSize, Offset);
-					Offset += SegmentSize;
-				}
-			}
-		}
-		void* FileHandle = BlockFile.Detach();
-		BlockBuffer		 = IoBuffer(IoBuffer::File, FileHandle, 0, Offset, /*IsWholeFile*/ true);
-		BlockBuffer.SetDeleteOnClose(true);
-		return BlockBuffer;
-	}
-
 	RemoteProjectStore::Result WriteOplogSection(ProjectStore::Oplog& Oplog, const CbObjectView& SectionObject, JobContext* OptionalContext)
 	{
 		using namespace std::literals;
@@ -1635,9 +1578,22 @@ BuildContainer(CidStore&																	ChunkStore,
 
 									std::filesystem::path AttachmentPath = AttachmentTempPath;
 									AttachmentPath.append(RawHash.ToHexString());
+									uint32_t RetriesLeft = 3;
 
 									IoBuffer TempAttachmentBuffer =
-										remotestore_impl::WriteToTempFile(std::move(Compressed), AttachmentPath);
+										WriteToTempFile(std::move(Compressed).GetCompressed(), AttachmentPath, [&](std::error_code& Ec) {
+											if (RetriesLeft == 0)
+											{
+												return false;
+											}
+											ZEN_WARN("Failed to create temporary attachment '{}': '{}', retries left: {}.",
+													 AttachmentPath,
+													 Ec.message(),
+													 RetriesLeft);
+											Sleep(100 - (3 - RetriesLeft) * 100);  // Total 600 ms
+											RetriesLeft--;
+											return true;
+										});
 									ZEN_INFO("Saved temp attachment to '{}', {} ({})",
 											 AttachmentPath,
 											 NiceBytes(RawSize),
@@ -1656,7 +1612,21 @@ BuildContainer(CidStore&																	ChunkStore,
 								std::filesystem::path AttachmentPath = AttachmentTempPath;
 								AttachmentPath.append(RawHash.ToHexString());
 
-								IoBuffer TempAttachmentBuffer = remotestore_impl::WriteToTempFile(std::move(Compressed), AttachmentPath);
+								uint32_t RetriesLeft = 3;
+								IoBuffer TempAttachmentBuffer =
+									WriteToTempFile(std::move(Compressed).GetCompressed(), AttachmentPath, [&](std::error_code& Ec) {
+										if (RetriesLeft == 0)
+										{
+											return false;
+										}
+										ZEN_WARN("Failed to create temporary attachment '{}': '{}', retries left: {}.",
+												 AttachmentPath,
+												 Ec.message(),
+												 RetriesLeft);
+										Sleep(100 - (3 - RetriesLeft) * 100);  // Total 600 ms
+										RetriesLeft--;
+										return true;
+									});
 								ZEN_INFO("Saved temp attachment to '{}', {} ({})",
 										 AttachmentPath,
 										 NiceBytes(RawSize),
@@ -2392,7 +2362,17 @@ SaveOplog(CidStore&				 ChunkStore,
 		BlockPath.append(Block.BlockHash.ToHexString());
 		try
 		{
-			IoBuffer				   BlockBuffer = remotestore_impl::WriteToTempFile(std::move(CompressedBlock), BlockPath);
+			uint32_t RetriesLeft = 3;
+			IoBuffer BlockBuffer = WriteToTempFile(std::move(CompressedBlock).GetCompressed(), BlockPath, [&](std::error_code& Ec) {
+				if (RetriesLeft == 0)
+				{
+					return false;
+				}
+				ZEN_WARN("Failed to create temporary oplog block '{}': '{}', retries left: {}.", BlockPath, Ec.message(), RetriesLeft);
+				Sleep(100 - (3 - RetriesLeft) * 100);  // Total 600 ms
+				RetriesLeft--;
+				return true;
+			});
 			RwLock::ExclusiveLockScope __(AttachmentsLock);
 			CreatedBlocks.insert({Block.BlockHash, {.Payload = std::move(BlockBuffer), .Block = std::move(Block)}});
 			ZEN_DEBUG("Saved temp block to '{}', {}", AttachmentTempPath, NiceBytes(BlockBuffer.GetSize()));