path: root/zenstore/basicfile.cpp

// Copyright Epic Games, Inc. All Rights Reserved.

#include "zenstore/basicfile.h"

#include <zencore/except.h>
#include <zencore/filesystem.h>
#include <zencore/fmtutils.h>
#include <zencore/testing.h>
#include <zencore/testutils.h>

#include <fmt/format.h>
#include <gsl/gsl-lite.hpp>

namespace zen {

using namespace fmt::literals;

BasicFile::~BasicFile()
{
	Close();
}

void
BasicFile::Open(std::filesystem::path FileName, bool IsCreate)
{
	std::error_code Ec;
	Open(FileName, IsCreate, Ec);

	if (Ec)
	{
		throw std::system_error(Ec, "failed to open file '{}'"_format(FileName));
	}
}

void
BasicFile::Open(std::filesystem::path FileName, bool IsCreate, std::error_code& Ec)
{
	Ec.clear();

	const DWORD dwCreationDisposition = IsCreate ? CREATE_ALWAYS : OPEN_EXISTING;
	DWORD		dwDesiredAccess		  = GENERIC_READ | GENERIC_WRITE;
	const DWORD dwShareMode			  = FILE_SHARE_READ;
	const DWORD dwFlagsAndAttributes  = FILE_ATTRIBUTE_NORMAL;
	HANDLE		hTemplateFile		  = nullptr;

	if (IsCreate)
	{
		dwDesiredAccess |= DELETE;
	}

	HANDLE FileHandle = CreateFile(FileName.c_str(),
								   dwDesiredAccess,
								   dwShareMode,
								   /* lpSecurityAttributes */ nullptr,
								   dwCreationDisposition,
								   dwFlagsAndAttributes,
								   hTemplateFile);

	if (FileHandle == INVALID_HANDLE_VALUE)
	{
		Ec = zen::MakeErrorCodeFromLastError();

		return;
	}

	m_FileHandle = FileHandle;
}

void
BasicFile::Close()
{
	if (m_FileHandle)
	{
		::CloseHandle(m_FileHandle);
		m_FileHandle = nullptr;
	}
}

void
BasicFile::Read(void* Data, uint64_t BytesToRead, uint64_t FileOffset)
{
	const uint64_t MaxChunkSize = 2u * 1024 * 1024 * 1024;

	while (BytesToRead)
	{
		const uint64_t NumberOfBytesToRead = Min(BytesToRead, MaxChunkSize);

		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);

		ZEN_ASSERT(dwNumberOfBytesRead == NumberOfBytesToRead);

		if (!Success)
		{
			ThrowLastError("Failed to read from file '{}'"_format(zen::PathFromHandle(m_FileHandle)));
		}

		BytesToRead -= NumberOfBytesToRead;
		FileOffset += NumberOfBytesToRead;
		Data = reinterpret_cast<uint8_t*>(Data) + NumberOfBytesToRead;
	}
}

IoBuffer
BasicFile::ReadAll()
{
	IoBuffer Buffer(FileSize());
	Read(Buffer.MutableData(), Buffer.Size(), 0);
	return Buffer;
}

void
BasicFile::StreamFile(std::function<void(const void* Data, uint64_t Size)>&& ChunkFun)
{
	StreamByteRange(0, FileSize(), std::move(ChunkFun));
}

void
BasicFile::StreamByteRange(uint64_t FileOffset, uint64_t Size, std::function<void(const void* Data, uint64_t Size)>&& ChunkFun)
{
	const uint64_t ChunkSize = 128 * 1024;
	IoBuffer	   ReadBuffer{ChunkSize};
	void*		   BufferPtr = ReadBuffer.MutableData();

	uint64_t RemainBytes   = Size;
	uint64_t CurrentOffset = FileOffset;

	while (RemainBytes)
	{
		const uint64_t ThisChunkBytes = zen::Min(ChunkSize, RemainBytes);

		Read(BufferPtr, ThisChunkBytes, CurrentOffset);

		ChunkFun(BufferPtr, ThisChunkBytes);

		CurrentOffset += ThisChunkBytes;
		RemainBytes -= ThisChunkBytes;
	}
}

void 
BasicFile::Write(MemoryView Data, uint64_t FileOffset, std::error_code& Ec)
{
	Write(Data.GetData(), Data.GetSize(), FileOffset, Ec);
}

void
BasicFile::Write(const void* Data, uint64_t Size, uint64_t FileOffset, std::error_code& Ec)
{
	Ec.clear();

	const uint64_t MaxChunkSize = 2u * 1024 * 1024 * 1024;

	while (Size)
	{
		const uint64_t NumberOfBytesToWrite = Min(Size, MaxChunkSize);

		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);

		if (!Success)
		{
			Ec = MakeErrorCodeFromLastError();

			return;
		}

		Size -= NumberOfBytesToWrite;
		FileOffset += NumberOfBytesToWrite;
		Data = reinterpret_cast<const uint8_t*>(Data) + NumberOfBytesToWrite;
	}
}

void
BasicFile::Write(MemoryView Data, uint64_t FileOffset)
{
	Write(Data.GetData(), Data.GetSize(), FileOffset);
}

void
BasicFile::Write(const void* Data, uint64_t Size, uint64_t Offset)
{
	std::error_code Ec;
	Write(Data, Size, Offset, Ec);

	if (Ec)
	{
		throw std::system_error(Ec, "Failed to write to file '{}'"_format(zen::PathFromHandle(m_FileHandle)));
	}
}

void
BasicFile::WriteAll(IoBuffer Data, std::error_code& Ec)
{
	Write(Data.Data(), Data.Size(), 0, Ec);
}

void
BasicFile::Flush()
{
	FlushFileBuffers(m_FileHandle);
}

uint64_t
BasicFile::FileSize()
{
	ULARGE_INTEGER liFileSize;
	liFileSize.LowPart = ::GetFileSize(m_FileHandle, &liFileSize.HighPart);

	return uint64_t(liFileSize.QuadPart);
}

//////////////////////////////////////////////////////////////////////////

TemporaryFile::~TemporaryFile()
{
	Close();
}

void
TemporaryFile::Close()
{
	if (m_FileHandle)
	{
		// Mark file for deletion when final handle is closed

		FILE_DISPOSITION_INFO Fdi{.DeleteFile = TRUE};

		SetFileInformationByHandle(m_FileHandle, FileDispositionInfo, &Fdi, sizeof Fdi);

		BasicFile::Close();
	}
}

void
TemporaryFile::CreateTemporary(std::filesystem::path TempDirName, std::error_code& Ec)
{
	StringBuilder<64> TempName;
	Oid::NewOid().ToString(TempName);

	m_TempPath = TempDirName / TempName.c_str();

	const bool IsCreate = true;

	Open(m_TempPath, IsCreate, Ec);
}

void
TemporaryFile::MoveTemporaryIntoPlace(std::filesystem::path FinalFileName, std::error_code& Ec)
{
	// We intentionally call the base class Close() since otherwise we'll end up
	// deleting the temporary file
	BasicFile::Close();

	std::filesystem::rename(m_TempPath, FinalFileName, Ec);
}

/*
		___________              __
		\__    ___/___   _______/  |_  ______
		  |    |_/ __ \ /  ___/\   __\/  ___/
		  |    |\  ___/ \___ \  |  |  \___ \
		  |____| \___  >____  > |__| /____  >
					 \/     \/            \/
*/

#if ZEN_WITH_TESTS

TEST_CASE("BasicFile")
{
	ScopedCurrentDirectoryChange _;

	BasicFile File1;
	CHECK_THROWS(File1.Open("zonk", false));
	CHECK_NOTHROW(File1.Open("zonk", true));
	CHECK_NOTHROW(File1.Write("abcd", 4, 0));
	CHECK(File1.FileSize() == 4);
	{
		IoBuffer Data = File1.ReadAll();
		CHECK(Data.Size() == 4);
		CHECK_EQ(memcmp(Data.Data(), "abcd", 4), 0);
	}
	CHECK_NOTHROW(File1.Write("efgh", 4, 2));
	CHECK(File1.FileSize() == 6);
	{
		IoBuffer Data = File1.ReadAll();
		CHECK(Data.Size() == 6);
		CHECK_EQ(memcmp(Data.Data(), "abefgh", 6), 0);
	}
}

TEST_CASE("TemporaryFile")
{
	ScopedCurrentDirectoryChange _;

	SUBCASE("DeleteOnClose")
	{
		TemporaryFile	TmpFile;
		std::error_code Ec;
		TmpFile.CreateTemporary(std::filesystem::current_path(), Ec);
		CHECK(!Ec);
		CHECK(std::filesystem::exists(TmpFile.GetPath()));
		TmpFile.Close();
		CHECK(std::filesystem::exists(TmpFile.GetPath()) == false);
	}

	SUBCASE("MoveIntoPlace")
	{
		TemporaryFile	TmpFile;
		std::error_code Ec;
		TmpFile.CreateTemporary(std::filesystem::current_path(), Ec);
		CHECK(!Ec);
		std::filesystem::path TempPath	= TmpFile.GetPath();
		std::filesystem::path FinalPath = std::filesystem::current_path() / "final";
		CHECK(std::filesystem::exists(TempPath));
		TmpFile.MoveTemporaryIntoPlace(FinalPath, Ec);
		CHECK(!Ec);
		CHECK(std::filesystem::exists(TempPath) == false);
		CHECK(std::filesystem::exists(FinalPath));
	}
}

void
basicfile_forcelink()
{
}

#endif

}  // namespace zen