http client streaming upload (#413)

- Improvement: Add streaming upload from HttpClient to reduce I/O caused by excessive MMap usage

4 files changed, 155 insertions, 173 deletions

diff --git a/src/zencore/basicfile.cpp b/src/zencore/basicfile.cpp
index 12ee26155..993f2b616 100644
--- a/src/zencore/basicfile.cpp
+++ b/src/zencore/basicfile.cpp
@@ -181,58 +181,18 @@ BasicFile::ReadRange(uint64_t FileOffset, uint64_t ByteCount)
 void
 BasicFile::Read(void* Data, uint64_t BytesToRead, uint64_t FileOffset)
 {
-	const uint64_t MaxChunkSize = 2u * 1024 * 1024 * 1024;
-
-	while (BytesToRead)
+	const uint64_t	MaxChunkSize = 2u * 1024 * 1024 * 1024;
+	std::error_code Ec;
+	ReadFile(m_FileHandle, Data, BytesToRead, FileOffset, MaxChunkSize, Ec);
+	if (Ec)
 	{
-		const uint64_t NumberOfBytesToRead = Min(BytesToRead, MaxChunkSize);
-		int32_t		   Error			   = 0;
-		size_t		   BytesRead		   = 0;
-
-#if ZEN_PLATFORM_WINDOWS
-		OVERLAPPED Ovl{};
-
-		Ovl.Offset	   = DWORD(FileOffset & 0xffff'ffffu);
-		Ovl.OffsetHigh = DWORD(FileOffset >> 32);
-
-		DWORD dwNumberOfBytesRead = 0;
-		BOOL  Success			  = ::ReadFile(m_FileHandle, Data, DWORD(NumberOfBytesToRead), &dwNumberOfBytesRead, &Ovl);
-		if (Success)
-		{
-			BytesRead = size_t(dwNumberOfBytesRead);
-		}
-		else
-		{
-			Error = zen::GetLastError();
-		}
-#else
-		static_assert(sizeof(off_t) >= sizeof(uint64_t), "sizeof(off_t) does not support large files");
-		int		Fd		   = int(uintptr_t(m_FileHandle));
-		ssize_t ReadResult = pread(Fd, Data, NumberOfBytesToRead, FileOffset);
-		if (ReadResult != -1)
-		{
-			BytesRead = size_t(ReadResult);
-		}
-		else
-		{
-			Error = zen::GetLastError();
-		}
-#endif
-
-		if (Error || (BytesRead != NumberOfBytesToRead))
-		{
-			std::error_code DummyEc;
-			throw std::system_error(std::error_code(Error, std::system_category()),
-									fmt::format("ReadFile/pread failed (offset {:#x}, size {:#x}) file: '{}' (size {:#x})",
-												FileOffset,
-												NumberOfBytesToRead,
-												PathFromHandle(m_FileHandle, DummyEc),
-												FileSizeFromHandle(m_FileHandle)));
-		}
-
-		BytesToRead -= NumberOfBytesToRead;
-		FileOffset += NumberOfBytesToRead;
-		Data = reinterpret_cast<uint8_t*>(Data) + NumberOfBytesToRead;
+		std::error_code DummyEc;
+		throw std::system_error(Ec,
+								fmt::format("BasicFile::Read: ReadFile/pread failed (offset {:#x}, size {:#x}) file: '{}' (size {:#x})",
+											FileOffset,
+											BytesToRead,
+											PathFromHandle(m_FileHandle, DummyEc),
+											FileSizeFromHandle(m_FileHandle)));
 	}
 }
 
@@ -323,43 +283,9 @@ BasicFile::Write(MemoryView Data, uint64_t FileOffset, std::error_code& Ec)
 void
 BasicFile::Write(const void* Data, uint64_t Size, uint64_t FileOffset, std::error_code& Ec)
 {
-	ZEN_ASSERT(m_FileHandle != nullptr);
-
-	Ec.clear();
-
 	const uint64_t MaxChunkSize = 2u * 1024 * 1024 * 1024;
 
-	while (Size)
-	{
-		const uint64_t NumberOfBytesToWrite = Min(Size, MaxChunkSize);
-
-#if ZEN_PLATFORM_WINDOWS
-		OVERLAPPED Ovl{};
-
-		Ovl.Offset	   = DWORD(FileOffset & 0xffff'ffffu);
-		Ovl.OffsetHigh = DWORD(FileOffset >> 32);
-
-		DWORD dwNumberOfBytesWritten = 0;
-
-		BOOL Success = ::WriteFile(m_FileHandle, Data, DWORD(NumberOfBytesToWrite), &dwNumberOfBytesWritten, &Ovl);
-#else
-		static_assert(sizeof(off_t) >= sizeof(uint64_t), "sizeof(off_t) does not support large files");
-		int	 Fd			  = int(uintptr_t(m_FileHandle));
-		int	 BytesWritten = pwrite(Fd, Data, NumberOfBytesToWrite, FileOffset);
-		bool Success	  = (BytesWritten > 0);
-#endif
-
-		if (!Success)
-		{
-			Ec = MakeErrorCodeFromLastError();
-
-			return;
-		}
-
-		Size -= NumberOfBytesToWrite;
-		FileOffset += NumberOfBytesToWrite;
-		Data = reinterpret_cast<const uint8_t*>(Data) + NumberOfBytesToWrite;
-	}
+	WriteFile(m_FileHandle, Data, Size, FileOffset, MaxChunkSize, Ec);
 }
 
 void
@@ -405,59 +331,20 @@ BasicFile::Flush()
 uint64_t
 BasicFile::FileSize() const
 {
-#if ZEN_PLATFORM_WINDOWS
-	ULARGE_INTEGER liFileSize;
-	liFileSize.LowPart = ::GetFileSize(m_FileHandle, &liFileSize.HighPart);
-	if (liFileSize.LowPart == INVALID_FILE_SIZE)
-	{
-		int Error = zen::GetLastError();
-		if (Error)
-		{
-			std::error_code Dummy;
-			ThrowSystemError(Error, fmt::format("Failed to get file size from file '{}'", PathFromHandle(m_FileHandle, Dummy)));
-		}
-	}
-	return uint64_t(liFileSize.QuadPart);
-#else
-	int Fd = int(uintptr_t(m_FileHandle));
-	static_assert(sizeof(decltype(stat::st_size)) == sizeof(uint64_t), "fstat() doesn't support large files");
-	struct stat Stat;
-	if (fstat(Fd, &Stat) == -1)
+	std::error_code Ec;
+	uint64_t		FileSize = FileSizeFromHandle(m_FileHandle, Ec);
+	if (Ec)
 	{
 		std::error_code Dummy;
-		ThrowSystemError(GetLastError(), fmt::format("Failed to get file size from file '{}'", PathFromHandle(m_FileHandle, Dummy)));
+		ThrowSystemError(Ec.value(), fmt::format("Failed to get file size from file '{}'", PathFromHandle(m_FileHandle, Dummy)));
 	}
-	return uint64_t(Stat.st_size);
-#endif
+	return FileSize;
 }
 
 uint64_t
 BasicFile::FileSize(std::error_code& Ec) const
 {
-#if ZEN_PLATFORM_WINDOWS
-	ULARGE_INTEGER liFileSize;
-	liFileSize.LowPart = ::GetFileSize(m_FileHandle, &liFileSize.HighPart);
-	if (liFileSize.LowPart == INVALID_FILE_SIZE)
-	{
-		int Error = zen::GetLastError();
-		if (Error)
-		{
-			Ec = MakeErrorCode(Error);
-			return 0;
-		}
-	}
-	return uint64_t(liFileSize.QuadPart);
-#else
-	int Fd = int(uintptr_t(m_FileHandle));
-	static_assert(sizeof(decltype(stat::st_size)) == sizeof(uint64_t), "fstat() doesn't support large files");
-	struct stat Stat;
-	if (fstat(Fd, &Stat) == -1)
-	{
-		Ec = MakeErrorCodeFromLastError();
-		return 0;
-	}
-	return uint64_t(Stat.st_size);
-#endif
+	return FileSizeFromHandle(m_FileHandle, Ec);
 }
 
 void
diff --git a/src/zencore/filesystem.cpp b/src/zencore/filesystem.cpp
index f71397922..0a9b2a73a 100644
--- a/src/zencore/filesystem.cpp
+++ b/src/zencore/filesystem.cpp
@@ -1052,6 +1052,100 @@ CopyTree(std::filesystem::path FromPath, std::filesystem::path ToPath, const Cop
 }
 
 void
+WriteFile(void* NativeHandle, const void* Data, uint64_t Size, uint64_t FileOffset, uint64_t ChunkSize, std::error_code& Ec)
+{
+	ZEN_ASSERT(NativeHandle != nullptr);
+
+	Ec.clear();
+
+	while (Size)
+	{
+		const uint64_t NumberOfBytesToWrite = Min(Size, ChunkSize);
+
+#if ZEN_PLATFORM_WINDOWS
+		OVERLAPPED Ovl{};
+
+		Ovl.Offset	   = DWORD(FileOffset & 0xffff'ffffu);
+		Ovl.OffsetHigh = DWORD(FileOffset >> 32);
+
+		DWORD dwNumberOfBytesWritten = 0;
+
+		BOOL Success = ::WriteFile(NativeHandle, Data, DWORD(NumberOfBytesToWrite), &dwNumberOfBytesWritten, &Ovl);
+#else
+		static_assert(sizeof(off_t) >= sizeof(uint64_t), "sizeof(off_t) does not support large files");
+		int	 Fd			  = int(uintptr_t(NativeHandle));
+		int	 BytesWritten = pwrite(Fd, Data, NumberOfBytesToWrite, FileOffset);
+		bool Success	  = (BytesWritten > 0);
+#endif
+
+		if (!Success)
+		{
+			Ec = MakeErrorCodeFromLastError();
+			return;
+		}
+
+		Size -= NumberOfBytesToWrite;
+		FileOffset += NumberOfBytesToWrite;
+		Data = reinterpret_cast<const uint8_t*>(Data) + NumberOfBytesToWrite;
+	}
+}
+
+void
+ReadFile(void* NativeHandle, void* Data, uint64_t Size, uint64_t FileOffset, uint64_t ChunkSize, std::error_code& Ec)
+{
+	while (Size)
+	{
+		const uint64_t NumberOfBytesToRead = Min(Size, ChunkSize);
+		size_t		   BytesRead		   = 0;
+
+#if ZEN_PLATFORM_WINDOWS
+		OVERLAPPED Ovl{};
+
+		Ovl.Offset	   = DWORD(FileOffset & 0xffff'ffffu);
+		Ovl.OffsetHigh = DWORD(FileOffset >> 32);
+
+		DWORD dwNumberOfBytesRead = 0;
+		BOOL  Success			  = ::ReadFile(NativeHandle, Data, DWORD(NumberOfBytesToRead), &dwNumberOfBytesRead, &Ovl);
+		if (Success)
+		{
+			BytesRead = size_t(dwNumberOfBytesRead);
+		}
+		else if ((BytesRead != NumberOfBytesToRead))
+		{
+			Ec = MakeErrorCode(ERROR_HANDLE_EOF);
+			return;
+		}
+		else
+		{
+			Ec = MakeErrorCodeFromLastError();
+			return;
+		}
+#else
+		static_assert(sizeof(off_t) >= sizeof(uint64_t), "sizeof(off_t) does not support large files");
+		int		Fd		   = int(uintptr_t(NativeHandle));
+		ssize_t ReadResult = pread(Fd, Data, NumberOfBytesToRead, FileOffset);
+		if (ReadResult != -1)
+		{
+			BytesRead = size_t(ReadResult);
+		}
+		else if ((BytesRead != NumberOfBytesToRead))
+		{
+			Ec = MakeErrorCode(EIO);
+			return;
+		}
+		else
+		{
+			Ec = MakeErrorCodeFromLastError();
+			return;
+		}
+#endif
+		Size -= NumberOfBytesToRead;
+		FileOffset += NumberOfBytesToRead;
+		Data = reinterpret_cast<uint8_t*>(Data) + NumberOfBytesToRead;
+	}
+}
+
+void
 WriteFile(std::filesystem::path Path, const IoBuffer* const* Data, size_t BufferCount)
 {
 #if ZEN_PLATFORM_WINDOWS
@@ -1921,23 +2015,41 @@ FileSizeFromPath(const std::filesystem::path& Path, std::error_code& Ec)
 }
 
 uint64_t
-FileSizeFromHandle(void* NativeHandle)
+FileSizeFromHandle(void* NativeHandle, std::error_code& Ec)
 {
-	uint64_t FileSize = ~0ull;
-
 #if ZEN_PLATFORM_WINDOWS
 	BY_HANDLE_FILE_INFORMATION Bhfh = {};
 	if (GetFileInformationByHandle(NativeHandle, &Bhfh))
 	{
-		FileSize = uint64_t(Bhfh.nFileSizeHigh) << 32 | Bhfh.nFileSizeLow;
+		return uint64_t(Bhfh.nFileSizeHigh) << 32 | Bhfh.nFileSizeLow;
+	}
+	else
+	{
+		Ec = MakeErrorCodeFromLastError();
+		return 0;
 	}
 #else
-	int			Fd = int(intptr_t(NativeHandle));
+	int Fd = int(intptr_t(NativeHandle));
+	static_assert(sizeof(decltype(stat::st_size)) == sizeof(uint64_t), "fstat() doesn't support large files");
 	struct stat Stat;
-	fstat(Fd, &Stat);
-	FileSize	   = size_t(Stat.st_size);
+	if (fstat(Fd, &Stat) == -1)
+	{
+		Ec = MakeErrorCodeFromLastError();
+		return 0;
+	}
+	return uint64_t(Stat.st_size);
 #endif
+}
 
+uint64_t
+FileSizeFromHandle(void* NativeHandle)
+{
+	std::error_code Ec;
+	uint64_t		FileSize = FileSizeFromHandle(NativeHandle, Ec);
+	if (Ec)
+	{
+		return ~0ull;
+	}
 	return FileSize;
 }
 
diff --git a/src/zencore/include/zencore/filesystem.h b/src/zencore/include/zencore/filesystem.h
index e62170eba..dfd0eedc9 100644
--- a/src/zencore/include/zencore/filesystem.h
+++ b/src/zencore/include/zencore/filesystem.h
@@ -102,6 +102,10 @@ ZENCORE_API uint64_t FileSizeFromPath(const std::filesystem::path& Path, std::er
  */
 ZENCORE_API uint64_t FileSizeFromHandle(void* NativeHandle);
 
+/** Query file size from native file handle
+ */
+ZENCORE_API uint64_t FileSizeFromHandle(void* NativeHandle, std::error_code& Ec);
+
 /** Get a native time tick of last modification time
  */
 ZENCORE_API uint64_t GetModificationTickFromHandle(void* NativeHandle, std::error_code& Ec);
@@ -167,6 +171,13 @@ ZENCORE_API void ScanFile(void*												   NativeHandle,
 						  uint64_t											   Size,
 						  uint64_t											   ChunkSize,
 						  std::function<void(const void* Data, size_t Size)>&& ProcessFunc);
+ZENCORE_API void WriteFile(void*			NativeHandle,
+						   const void*		Data,
+						   uint64_t			Size,
+						   uint64_t			FileOffset,
+						   uint64_t			ChunkSize,
+						   std::error_code& Ec);
+ZENCORE_API void ReadFile(void* NativeHandle, void* Data, uint64_t Size, uint64_t FileOffset, uint64_t ChunkSize, std::error_code& Ec);
 
 struct CopyFileOptions
 {
diff --git a/src/zencore/iobuffer.cpp b/src/zencore/iobuffer.cpp
index 3b5c89c3e..8e9a37a27 100644
--- a/src/zencore/iobuffer.cpp
+++ b/src/zencore/iobuffer.cpp
@@ -297,49 +297,21 @@ IoBufferExtendedCore::Materialize() const
 
 		AllocateBuffer(m_DataBytes, sizeof(void*));
 		NewFlags |= kIsOwnedByThis;
-		int32_t Error	  = 0;
-		size_t	BytesRead = 0;
 
-#if ZEN_PLATFORM_WINDOWS
-		OVERLAPPED Ovl{};
-
-		Ovl.Offset	   = DWORD(m_FileOffset & 0xffff'ffffu);
-		Ovl.OffsetHigh = DWORD(m_FileOffset >> 32);
-
-		DWORD dwNumberOfBytesRead = 0;
-		BOOL  Success			  = ::ReadFile(m_FileHandle, (void*)m_DataPtr, DWORD(m_DataBytes), &dwNumberOfBytesRead, &Ovl) == TRUE;
-		if (Success)
-		{
-			BytesRead = size_t(dwNumberOfBytesRead);
-		}
-		else
-		{
-			Error = zen::GetLastError();
-		}
-#else
-		static_assert(sizeof(off_t) >= sizeof(uint64_t), "sizeof(off_t) does not support large files");
-		int		Fd		   = int(uintptr_t(m_FileHandle));
-		ssize_t ReadResult = pread(Fd, (void*)m_DataPtr, m_DataBytes, m_FileOffset);
-		if (ReadResult != -1)
-		{
-			BytesRead = size_t(ReadResult);
-		}
-		else
-		{
-			Error = zen::GetLastError();
-		}
-#endif	// ZEN_PLATFORM_WINDOWS
-		if (Error || (BytesRead != m_DataBytes))
+		std::error_code Ec;
+		ReadFile(m_FileHandle, (void*)m_DataPtr, m_DataBytes, m_FileOffset, DisableMMapSizeLimit, Ec);
+		if (Ec)
 		{
 			std::error_code DummyEc;
-			ZEN_WARN("IoBufferExtendedCore::Materialize: ReadFile/pread failed (offset {:#x}, size {:#x}) file: '{}' (size {:#x}), {}",
+			ZEN_WARN("IoBufferExtendedCore::Materialize: ReadFile/pread failed (offset {:#x}, size {:#x}) file: '{}' (size {:#x}), {} ({})",
 					 m_FileOffset,
 					 m_DataBytes,
 					 zen::PathFromHandle(m_FileHandle, DummyEc),
 					 zen::FileSizeFromHandle(m_FileHandle),
-					 GetSystemErrorAsString(Error));
+					 Ec.message(),
+					 Ec.value());
 			throw std::system_error(
-				std::error_code(Error, std::system_category()),
+				Ec,
 				fmt::format("IoBufferExtendedCore::Materialize: ReadFile/pread failed (offset {:#x}, size {:#x}) file: '{}' (size {:#x})",
 							m_FileOffset,
 							m_DataBytes,