path: root/zenstore/blockstore.cpp

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

#include "compactcas.h"

#include <zencore/fmtutils.h>
#include <zencore/logging.h>
#include <zencore/scopeguard.h>
#include <zenstore/blockstore.h>

#if ZEN_WITH_TESTS
#	include <zencore/compactbinarybuilder.h>
#	include <zencore/testing.h>
#	include <zencore/testutils.h>
#	include <algorithm>
#	include <random>
#endif

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

namespace zen {

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

BlockStoreFile::BlockStoreFile(const std::filesystem::path& BlockPath) : m_Path(BlockPath)
{
}

BlockStoreFile::~BlockStoreFile()
{
	m_IoBuffer = IoBuffer();
	m_File.Detach();
}

const std::filesystem::path&
BlockStoreFile::GetPath() const
{
	return m_Path;
}

void
BlockStoreFile::Open()
{
	m_File.Open(m_Path, BasicFile::Mode::kDelete);
	void* FileHandle = m_File.Handle();
	m_IoBuffer		 = IoBuffer(IoBuffer::File, FileHandle, 0, m_File.FileSize());
}

void
BlockStoreFile::Create(uint64_t InitialSize)
{
	auto ParentPath = m_Path.parent_path();
	if (!std::filesystem::is_directory(ParentPath))
	{
		CreateDirectories(ParentPath);
	}

	m_File.Open(m_Path, BasicFile::Mode::kTruncateDelete);
	if (InitialSize > 0)
	{
		m_File.SetFileSize(InitialSize);
	}
	void* FileHandle = m_File.Handle();
	m_IoBuffer		 = IoBuffer(IoBuffer::File, FileHandle, 0, InitialSize);
}

uint64_t
BlockStoreFile::FileSize()
{
	return m_File.FileSize();
}

void
BlockStoreFile::MarkAsDeleteOnClose(std::error_code& Ec)
{
	m_File.MarkAsDeleteOnClose(Ec);
}

IoBuffer
BlockStoreFile::GetChunk(uint64_t Offset, uint64_t Size)
{
	return IoBuffer(m_IoBuffer, Offset, Size);
}

void
BlockStoreFile::Read(void* Data, uint64_t Size, uint64_t FileOffset)
{
	m_File.Read(Data, Size, FileOffset);
}

void
BlockStoreFile::Write(const void* Data, uint64_t Size, uint64_t FileOffset)
{
	m_File.Write(Data, Size, FileOffset);
}

void
BlockStoreFile::Truncate(uint64_t Size)
{
	m_File.SetFileSize(Size);
}

void
BlockStoreFile::Flush()
{
	m_File.Flush();
}

void
BlockStoreFile::StreamByteRange(uint64_t FileOffset, uint64_t Size, std::function<void(const void* Data, uint64_t Size)>&& ChunkFun)
{
	m_File.StreamByteRange(FileOffset, Size, std::move(ChunkFun));
}

namespace {
	const char* DataExtension = ".ucas";

	std::filesystem::path GetBlockPath(const std::filesystem::path& BlocksBasePath, const uint32_t BlockIndex)
	{
		ExtendablePathBuilder<256> Path;

		char BlockHexString[9];
		ToHexNumber(BlockIndex, BlockHexString);

		Path.Append(BlocksBasePath);
		Path.AppendSeparator();
		Path.AppendAsciiRange(BlockHexString, BlockHexString + 4);
		Path.AppendSeparator();
		Path.Append(BlockHexString);
		Path.Append(DataExtension);
		return Path.ToPath();
	}
}  // namespace

void
BlockStore::Initialize(const std::filesystem::path&			  BlocksBasePath,
					   uint64_t								  MaxBlockSize,
					   uint64_t								  MaxBlockCount,
					   const std::vector<BlockStoreLocation>& KnownLocations)
{
	ZEN_ASSERT(MaxBlockSize > 0);
	ZEN_ASSERT(MaxBlockCount > 0);
	ZEN_ASSERT(IsPow2(MaxBlockCount));

	m_BlocksBasePath = BlocksBasePath;
	m_MaxBlockSize	 = MaxBlockSize;

	m_TotalSize = 0;
	m_ChunkBlocks.clear();

	std::unordered_set<uint32_t> KnownBlocks;
	for (const auto& Entry : KnownLocations)
	{
		m_TotalSize.fetch_add(Entry.Size, std::memory_order_seq_cst);
		KnownBlocks.insert(Entry.BlockIndex);
	}

	if (std::filesystem::is_directory(m_BlocksBasePath))
	{
		std::vector<std::filesystem::path> FoldersToScan;
		FoldersToScan.push_back(m_BlocksBasePath);
		size_t FolderOffset = 0;
		while (FolderOffset < FoldersToScan.size())
		{
			for (const std::filesystem::directory_entry& Entry : std::filesystem::directory_iterator(FoldersToScan[FolderOffset]))
			{
				if (Entry.is_directory())
				{
					FoldersToScan.push_back(Entry.path());
					continue;
				}
				if (Entry.is_regular_file())
				{
					const std::filesystem::path Path = Entry.path();
					if (Path.extension() != DataExtension)
					{
						continue;
					}
					std::string FileName = Path.stem().string();
					uint32_t	BlockIndex;
					bool		OK = ParseHexNumber(FileName, BlockIndex);
					if (!OK)
					{
						continue;
					}
					if (!KnownBlocks.contains(BlockIndex))
					{
						// Log removing unreferenced block
						// Clear out unused blocks
						ZEN_INFO("removing unused block for '{}' at '{}'", m_BlocksBasePath, Path);
						std::error_code Ec;
						std::filesystem::remove(Path, Ec);
						if (Ec)
						{
							ZEN_WARN("Failed to delete file '{}' reason: '{}'", Path, Ec.message());
						}
						continue;
					}
					Ref<BlockStoreFile> BlockFile = new BlockStoreFile(Path);
					BlockFile->Open();
					m_ChunkBlocks[BlockIndex] = BlockFile;
				}
			}
			++FolderOffset;
		}
	}
	else
	{
		CreateDirectories(m_BlocksBasePath);
	}
}

BlockStoreLocation
BlockStore::WriteChunk(const void* Data, uint64_t Size, uint64_t Alignment)
{
	RwLock::ExclusiveLockScope InsertLock(m_InsertLock);

	uint32_t WriteBlockIndex = m_WriteBlockIndex.load(std::memory_order_acquire);
	bool	 IsWriting		 = m_WriteBlock != nullptr;
	if (!IsWriting || (m_CurrentInsertOffset + Size) > m_MaxBlockSize)
	{
		if (m_WriteBlock)
		{
			m_WriteBlock = nullptr;
		}
		{
			if (m_ChunkBlocks.size() == m_MaxBlockCount)
			{
				throw std::runtime_error(fmt::format("unable to allocate a new block in '{}'", m_BlocksBasePath));
			}
			WriteBlockIndex += IsWriting ? 1 : 0;
			while (m_ChunkBlocks.contains(WriteBlockIndex))
			{
				WriteBlockIndex = (WriteBlockIndex + 1) & (m_MaxBlockCount - 1);
			}
			std::filesystem::path BlockPath = GetBlockPath(m_BlocksBasePath, WriteBlockIndex);
			m_WriteBlock					= new BlockStoreFile(BlockPath);
			m_ChunkBlocks[WriteBlockIndex]	= m_WriteBlock;
			m_WriteBlockIndex.store(WriteBlockIndex, std::memory_order_release);
		}
		m_CurrentInsertOffset = 0;
		m_WriteBlock->Create(m_MaxBlockSize);
	}
	uint64_t InsertOffset		   = m_CurrentInsertOffset;
	m_CurrentInsertOffset		   = RoundUp(InsertOffset + Size, Alignment);
	Ref<BlockStoreFile> WriteBlock = m_WriteBlock;
	InsertLock.ReleaseNow();

	BlockStoreLocation Location{.BlockIndex = WriteBlockIndex, .Offset = InsertOffset, .Size = Size};
	WriteBlock->Write(Data, Size, InsertOffset);

	return Location;
}

/*
IoBuffer
BlockStore::ReadChunk(const BlockStoreLocation& Location)
{
	RwLock::SharedLockScope InsertLock(m_InsertLock);
	Ref<BlockStoreFile>		ChunkBlock = m_ChunkBlocks[Location.BlockIndex];
	InsertLock.ReleaseNow();
	return ChunkBlock->GetChunk(Location.Offset, Location.Size);
}
*/

Ref<BlockStoreFile>
BlockStore::GetChunkBlock(const BlockStoreLocation& Location)
{
	RwLock::SharedLockScope InsertLock(m_InsertLock);
	return m_ChunkBlocks[Location.BlockIndex];
}

void
BlockStore::Flush()
{
	RwLock::ExclusiveLockScope _(m_InsertLock);
	if (m_CurrentInsertOffset > 0)
	{
		uint32_t WriteBlockIndex = m_WriteBlockIndex.load(std::memory_order_acquire);
		WriteBlockIndex			 = (WriteBlockIndex + 1) & (m_MaxBlockCount - 1);
		m_WriteBlock			 = nullptr;
		m_WriteBlockIndex.store(WriteBlockIndex, std::memory_order_release);
		m_CurrentInsertOffset = 0;
	}
}

// TODO: Almost there - some bug remain and API might need tweaking
void
BlockStore::ReclaimSpace(const std::vector<BlockStoreLocation>& ChunkLocations,
						 const std::vector<size_t>&				KeepChunkIndexes,
						 uint64_t								PayloadAlignment,
						 bool									DryRun,
						 const ReclaimCallback&					Callback)
{
	if (ChunkLocations.empty())
	{
		return;
	}
	uint64_t WriteBlockTimeUs		 = 0;
	uint64_t WriteBlockLongestTimeUs = 0;
	uint64_t ReadBlockTimeUs		 = 0;
	uint64_t ReadBlockLongestTimeUs	 = 0;
	uint64_t TotalChunkCount		 = ChunkLocations.size();
	uint64_t DeletedSize			 = 0;
	uint64_t OldTotalSize			 = m_TotalSize.load(std::memory_order::relaxed);

	uint64_t MovedCount	  = 0;
	uint64_t DeletedCount = 0;

	Stopwatch  TotalTimer;
	const auto _ = MakeGuard([this,
							  &TotalTimer,
							  &WriteBlockTimeUs,
							  &WriteBlockLongestTimeUs,
							  &ReadBlockTimeUs,
							  &ReadBlockLongestTimeUs,
							  &TotalChunkCount,
							  &DeletedCount,
							  &MovedCount,
							  &DeletedSize,
							  OldTotalSize] {
		ZEN_INFO(
			"garbage collect for '{}' DONE after {}, write lock: {} ({}), read lock: {} ({}), collected {} bytes, deleted #{} and moved "
			"#{} "
			"of #{} "
			"chunks ({}).",
			m_BlocksBasePath,
			NiceTimeSpanMs(TotalTimer.GetElapsedTimeMs()),
			NiceLatencyNs(WriteBlockTimeUs),
			NiceLatencyNs(WriteBlockLongestTimeUs),
			NiceLatencyNs(ReadBlockTimeUs),
			NiceLatencyNs(ReadBlockLongestTimeUs),
			NiceBytes(DeletedSize),
			DeletedCount,
			MovedCount,
			TotalChunkCount,
			NiceBytes(OldTotalSize));
	});

	size_t	 BlockCount		   = 0;
	uint64_t ExcludeBlockIndex = 0x800000000ull;
	{
		RwLock::ExclusiveLockScope __(m_InsertLock);
		if (m_WriteBlock)
		{
			ExcludeBlockIndex = m_WriteBlockIndex.load(std::memory_order_acquire);
		}
		BlockCount = m_ChunkBlocks.size();
	}

	std::unordered_map<size_t, BlockStoreLocation> LocationLookup;
	LocationLookup.reserve(TotalChunkCount);

	std::unordered_set<size_t> KeepChunkMap;
	KeepChunkMap.reserve(KeepChunkIndexes.size());
	for (size_t KeepChunkIndex : KeepChunkIndexes)
	{
		const BlockStoreLocation& Location = ChunkLocations[KeepChunkIndex];
		if (Location.BlockIndex == ExcludeBlockIndex)
		{
			continue;
		}
		KeepChunkMap.insert(KeepChunkIndex);
	}
	std::unordered_set<size_t> DeleteChunkMap;
	DeleteChunkMap.reserve(ChunkLocations.size() - KeepChunkIndexes.size());

	std::unordered_map<uint32_t, size_t> BlockIndexToChunkMapIndex;
	std::vector<std::vector<size_t>>	 KeepChunks;
	std::vector<std::vector<size_t>>	 DeleteChunks;

	BlockIndexToChunkMapIndex.reserve(BlockCount);
	KeepChunks.reserve(BlockCount);
	DeleteChunks.reserve(BlockCount);
	size_t GuesstimateCountPerBlock = TotalChunkCount / BlockCount / 2;

	size_t	 DeleteCount  = 0;
	uint64_t NewTotalSize = 0;
	for (size_t Index = 0; Index < TotalChunkCount; ++Index)
	{
		const BlockStoreLocation& Location = ChunkLocations[Index];
		LocationLookup[Index]			   = Location;
		if (Location.BlockIndex == ExcludeBlockIndex)
		{
			continue;
		}

		auto   BlockIndexPtr = BlockIndexToChunkMapIndex.find(Location.BlockIndex);
		size_t ChunkMapIndex = 0;
		if (BlockIndexPtr == BlockIndexToChunkMapIndex.end())
		{
			ChunkMapIndex								   = KeepChunks.size();
			BlockIndexToChunkMapIndex[Location.BlockIndex] = ChunkMapIndex;
			KeepChunks.resize(ChunkMapIndex + 1);
			KeepChunks.back().reserve(GuesstimateCountPerBlock);
			DeleteChunks.resize(ChunkMapIndex + 1);
			DeleteChunks.back().reserve(GuesstimateCountPerBlock);
		}
		else
		{
			ChunkMapIndex = BlockIndexPtr->second;
		}

		if (KeepChunkMap.contains(Index))
		{
			std::vector<size_t>& IndexMap = KeepChunks[ChunkMapIndex];
			IndexMap.push_back(Index);
			NewTotalSize += Location.Size;
			continue;
		}
		std::vector<size_t>& IndexMap = DeleteChunks[ChunkMapIndex];
		IndexMap.push_back(Index);
		DeleteCount++;
	}

	std::unordered_set<uint32_t> BlocksToReWrite;
	BlocksToReWrite.reserve(BlockIndexToChunkMapIndex.size());
	for (const auto& Entry : BlockIndexToChunkMapIndex)
	{
		uint32_t				   BlockIndex	 = Entry.first;
		size_t					   ChunkMapIndex = Entry.second;
		const std::vector<size_t>& ChunkMap		 = DeleteChunks[ChunkMapIndex];
		if (ChunkMap.empty())
		{
			continue;
		}
		BlocksToReWrite.insert(BlockIndex);
	}

	if (DryRun)
	{
		uint64_t TotalSize = m_TotalSize.load(std::memory_order_relaxed);
		ZEN_INFO("garbage collect for '{}' DISABLED, found #{} {} chunks of total #{} {}",
				 m_BlocksBasePath,
				 DeleteCount,
				 NiceBytes(TotalSize - NewTotalSize),
				 TotalChunkCount,
				 NiceBytes(TotalSize));
		return;
	}

	std::unordered_map<size_t, BlockStoreLocation> MovedChunks;
	std::vector<size_t>							   RemovedChunks;

	Ref<BlockStoreFile> NewBlockFile;
	uint64_t			WriteOffset	  = 0;
	uint32_t			NewBlockIndex = 0;

	for (uint32_t BlockIndex : BlocksToReWrite)
	{
		const size_t ChunkMapIndex = BlockIndexToChunkMapIndex[BlockIndex];

		Ref<BlockStoreFile> OldBlockFile;
		{
			RwLock::SharedLockScope _i(m_InsertLock);
			OldBlockFile = m_ChunkBlocks[BlockIndex];
			ZEN_ASSERT(OldBlockFile);
		}

		const std::vector<size_t>& KeepMap = KeepChunks[ChunkMapIndex];
		if (KeepMap.empty())
		{
			const std::vector<size_t>& DeleteMap = DeleteChunks[ChunkMapIndex];
			for (size_t DeleteIndex : DeleteMap)
			{
				RemovedChunks.push_back(DeleteIndex);
				DeletedSize += ChunkLocations[DeleteIndex].Size;
				DeletedCount++;
			}
			Callback(MovedChunks, RemovedChunks);
			MovedChunks.clear();
			RemovedChunks.clear();
			{
				RwLock::ExclusiveLockScope _i(m_InsertLock);
				Stopwatch				   Timer;
				const auto				   __ = MakeGuard([&Timer, &WriteBlockTimeUs, &WriteBlockLongestTimeUs] {
					uint64_t ElapsedUs = Timer.GetElapsedTimeUs();
					WriteBlockTimeUs += ElapsedUs;
					WriteBlockLongestTimeUs = std::max(ElapsedUs, WriteBlockLongestTimeUs);
				});
				m_ChunkBlocks[BlockIndex]	  = nullptr;
			}
			ZEN_DEBUG("marking cas store file in '{}' for delete , block #{}, '{}'", m_BlocksBasePath, BlockIndex, OldBlockFile->GetPath());
			std::error_code Ec;
			OldBlockFile->MarkAsDeleteOnClose(Ec);
			if (Ec)
			{
				ZEN_WARN("Failed to flag file '{}' for deletion: '{}'", OldBlockFile->GetPath(), Ec.message());
			}
			continue;
		}

		std::vector<uint8_t> Chunk;
		for (const size_t& ChunkIndex : KeepMap)
		{
			const BlockStoreLocation ChunkLocation = ChunkLocations[ChunkIndex];
			Chunk.resize(ChunkLocation.Size);
			OldBlockFile->Read(Chunk.data(), Chunk.size(), ChunkLocation.Offset);

			if (!NewBlockFile || (WriteOffset + Chunk.size() > m_MaxBlockSize))
			{
				uint32_t NextBlockIndex = m_WriteBlockIndex.load(std::memory_order_relaxed);

				if (NewBlockFile)
				{
					NewBlockFile->Truncate(WriteOffset);
					NewBlockFile->Flush();
				}
				{
					Callback(MovedChunks, RemovedChunks);
					MovedChunks.clear();
					RemovedChunks.clear();
					RwLock::ExclusiveLockScope __(m_InsertLock);
					Stopwatch				   Timer;
					const auto				   ___ = MakeGuard([&Timer, &WriteBlockTimeUs, &WriteBlockLongestTimeUs] {
						uint64_t ElapsedUs = Timer.GetElapsedTimeUs();
						WriteBlockTimeUs += ElapsedUs;
						WriteBlockLongestTimeUs = std::max(ElapsedUs, WriteBlockLongestTimeUs);
					});
					if (m_ChunkBlocks.size() == m_MaxBlockCount)
					{
						ZEN_ERROR("unable to allocate a new block in '{}', count limit {} exeeded",
								  m_BlocksBasePath,
								  static_cast<uint64_t>(std::numeric_limits<uint32_t>::max()) + 1);
						return;
					}
					while (m_ChunkBlocks.contains(NextBlockIndex))
					{
						NextBlockIndex = (NextBlockIndex + 1) & (m_MaxBlockCount - 1);
					}
					std::filesystem::path NewBlockPath = GetBlockPath(m_BlocksBasePath, NextBlockIndex);
					NewBlockFile					   = new BlockStoreFile(NewBlockPath);
					m_ChunkBlocks[NextBlockIndex]	   = NewBlockFile;
				}

				std::error_code Error;
				DiskSpace		Space = DiskSpaceInfo(m_BlocksBasePath, Error);
				if (Error)
				{
					ZEN_ERROR("get disk space in '{}' FAILED, reason: '{}'", m_BlocksBasePath, Error.message());
					return;
				}
				if (Space.Free < m_MaxBlockSize)
				{
					uint64_t ReclaimedSpace = 0;  // GcCtx.ClaimGCReserve();
					if (Space.Free + ReclaimedSpace < m_MaxBlockSize)
					{
						ZEN_WARN("garbage collect for '{}' FAILED, required disk space {}, free {}",
								 m_BlocksBasePath,
								 m_MaxBlockSize,
								 NiceBytes(Space.Free + ReclaimedSpace));
						RwLock::ExclusiveLockScope _l(m_InsertLock);
						Stopwatch				   Timer;
						const auto				   __ = MakeGuard([&Timer, &WriteBlockTimeUs, &WriteBlockLongestTimeUs] {
							uint64_t ElapsedUs = Timer.GetElapsedTimeUs();
							WriteBlockTimeUs += ElapsedUs;
							WriteBlockLongestTimeUs = std::max(ElapsedUs, WriteBlockLongestTimeUs);
						});
						m_ChunkBlocks.erase(NextBlockIndex);
						return;
					}

					ZEN_INFO("using gc reserve for '{}', reclaimed {}, disk free {}",
							 m_BlocksBasePath,
							 ReclaimedSpace,
							 NiceBytes(Space.Free + ReclaimedSpace));
				}
				NewBlockFile->Create(m_MaxBlockSize);
				NewBlockIndex = NextBlockIndex;
				WriteOffset	  = 0;
			}

			NewBlockFile->Write(Chunk.data(), Chunk.size(), WriteOffset);
			MovedChunks[ChunkIndex] = {.BlockIndex = NewBlockIndex, .Offset = WriteOffset, .Size = Chunk.size()};
			WriteOffset				= RoundUp(WriteOffset + Chunk.size(), PayloadAlignment);
			MovedCount++;
		}
		Chunk.clear();
		if (NewBlockFile)
		{
			NewBlockFile->Truncate(WriteOffset);
			NewBlockFile->Flush();
			NewBlockFile = {};
		}

		const std::vector<size_t>& DeleteMap = DeleteChunks[ChunkMapIndex];
		for (size_t DeleteIndex : DeleteMap)
		{
			RemovedChunks.push_back(DeleteIndex);
			DeletedSize += ChunkLocations[DeleteIndex].Size;
			DeletedCount++;
		}

		Callback(MovedChunks, RemovedChunks);
		MovedChunks.clear();
		RemovedChunks.clear();
		{
			RwLock::ExclusiveLockScope __(m_InsertLock);
			Stopwatch				   Timer;
			const auto				   ___ = MakeGuard([&Timer, &ReadBlockTimeUs, &ReadBlockLongestTimeUs] {
				uint64_t ElapsedUs = Timer.GetElapsedTimeUs();
				ReadBlockTimeUs += ElapsedUs;
				ReadBlockLongestTimeUs = std::max(ElapsedUs, ReadBlockLongestTimeUs);
			});
			m_ChunkBlocks[BlockIndex]	   = nullptr;
		}
		ZEN_DEBUG("marking cas store file in '{}' for delete , block #{}, '{}'", m_BlocksBasePath, BlockIndex, OldBlockFile->GetPath());
		std::error_code Ec;
		OldBlockFile->MarkAsDeleteOnClose(Ec);
		if (Ec)
		{
			ZEN_WARN("Failed to flag file '{}' for deletion: '{}'", OldBlockFile->GetPath(), Ec.message());
		}
		OldBlockFile = nullptr;
	}

	return;
}

#if ZEN_WITH_TESTS

static bool
operator==(const BlockStoreLocation& Lhs, const BlockStoreLocation& Rhs)
{
	return Lhs.BlockIndex == Rhs.BlockIndex && Lhs.Offset == Rhs.Offset && Lhs.Size == Rhs.Size;
}

TEST_CASE("blockstore.blockstoredisklocation")
{
	BlockStoreLocation Zero = BlockStoreLocation{.BlockIndex = 0, .Offset = 0, .Size = 0};
	CHECK(Zero == BlockStoreDiskLocation(Zero, 4).Get(4));

	BlockStoreLocation MaxBlockIndex = BlockStoreLocation{.BlockIndex = BlockStoreDiskLocation::MaxBlockIndex, .Offset = 0, .Size = 0};
	CHECK(MaxBlockIndex == BlockStoreDiskLocation(MaxBlockIndex, 4).Get(4));

	BlockStoreLocation MaxOffset = BlockStoreLocation{.BlockIndex = 0, .Offset = BlockStoreDiskLocation::MaxOffset * 4, .Size = 0};
	CHECK(MaxOffset == BlockStoreDiskLocation(MaxOffset, 4).Get(4));

	BlockStoreLocation MaxSize = BlockStoreLocation{.BlockIndex = 0, .Offset = 0, .Size = std::numeric_limits<uint32_t>::max()};
	CHECK(MaxSize == BlockStoreDiskLocation(MaxSize, 4).Get(4));

	BlockStoreLocation MaxBlockIndexAndOffset =
		BlockStoreLocation{.BlockIndex = BlockStoreDiskLocation::MaxBlockIndex, .Offset = BlockStoreDiskLocation::MaxOffset * 4, .Size = 0};
	CHECK(MaxBlockIndexAndOffset == BlockStoreDiskLocation(MaxBlockIndexAndOffset, 4).Get(4));

	BlockStoreLocation MaxAll = BlockStoreLocation{.BlockIndex = BlockStoreDiskLocation::MaxBlockIndex,
												   .Offset	   = BlockStoreDiskLocation::MaxOffset * 4,
												   .Size	   = std::numeric_limits<uint32_t>::max()};
	CHECK(MaxAll == BlockStoreDiskLocation(MaxAll, 4).Get(4));

	BlockStoreLocation MaxAll4096 = BlockStoreLocation{.BlockIndex = BlockStoreDiskLocation::MaxBlockIndex,
													   .Offset	   = BlockStoreDiskLocation::MaxOffset * 4096,
													   .Size	   = std::numeric_limits<uint32_t>::max()};
	CHECK(MaxAll4096 == BlockStoreDiskLocation(MaxAll4096, 4096).Get(4096));

	BlockStoreLocation Middle = BlockStoreLocation{.BlockIndex = (BlockStoreDiskLocation::MaxBlockIndex) / 2,
												   .Offset	   = ((BlockStoreDiskLocation::MaxOffset) / 2) * 4,
												   .Size	   = std::numeric_limits<uint32_t>::max() / 2};
	CHECK(Middle == BlockStoreDiskLocation(Middle, 4).Get(4));
}

TEST_CASE("blockstore.blockfile")
{
	ScopedTemporaryDirectory TempDir;
	auto					 RootDirectory = TempDir.Path() / "blocks";
	CreateDirectories(RootDirectory);

	{
		BlockStoreFile File1(RootDirectory / "1");
		File1.Create(16384);
		CHECK(File1.FileSize() == 16384);
		File1.Write("data", 5, 0);
		IoBuffer DataChunk = File1.GetChunk(0, 5);
		File1.Write("boop", 5, 5);
		IoBuffer	BoopChunk = File1.GetChunk(5, 5);
		const char* Data	  = static_cast<const char*>(DataChunk.GetData());
		CHECK(std::string(Data) == "data");
		const char* Boop = static_cast<const char*>(BoopChunk.GetData());
		CHECK(std::string(Boop) == "boop");
		File1.Flush();
	}
	{
		BlockStoreFile File1(RootDirectory / "1");
		File1.Open();

		char DataRaw[5];
		File1.Read(DataRaw, 5, 0);
		CHECK(std::string(DataRaw) == "data");
		IoBuffer DataChunk = File1.GetChunk(0, 5);

		char BoopRaw[5];
		File1.Read(BoopRaw, 5, 5);
		CHECK(std::string(BoopRaw) == "boop");

		IoBuffer	BoopChunk = File1.GetChunk(5, 5);
		const char* Data	  = static_cast<const char*>(DataChunk.GetData());
		CHECK(std::string(Data) == "data");
		const char* Boop = static_cast<const char*>(BoopChunk.GetData());
		CHECK(std::string(Boop) == "boop");
	}

	{
		IoBuffer DataChunk;
		IoBuffer BoopChunk;

		{
			BlockStoreFile File1(RootDirectory / "1");
			File1.Open();
			DataChunk = File1.GetChunk(0, 5);
			BoopChunk = File1.GetChunk(5, 5);
		}

		CHECK(std::filesystem::exists(RootDirectory / "1"));

		const char* Data = static_cast<const char*>(DataChunk.GetData());
		CHECK(std::string(Data) == "data");
		const char* Boop = static_cast<const char*>(BoopChunk.GetData());
		CHECK(std::string(Boop) == "boop");
	}
	CHECK(std::filesystem::exists(RootDirectory / "1"));

	{
		IoBuffer DataChunk;
		IoBuffer BoopChunk;

		{
			BlockStoreFile File1(RootDirectory / "1");
			File1.Open();
			std::error_code Ec;
			File1.MarkAsDeleteOnClose(Ec);
			CHECK(!Ec);
			DataChunk = File1.GetChunk(0, 5);
			BoopChunk = File1.GetChunk(5, 5);
		}

		const char* Data = static_cast<const char*>(DataChunk.GetData());
		CHECK(std::string(Data) == "data");
		const char* Boop = static_cast<const char*>(BoopChunk.GetData());
		CHECK(std::string(Boop) == "boop");
	}
	CHECK(!std::filesystem::exists(RootDirectory / "1"));
}

#endif

void
blockstore_forcelink()
{
}

}  // namespace zen