long filename support (#330)

- Bugfix: Long file paths now works correctly on Windows

9 files changed, 117 insertions, 117 deletions

diff --git a/src/zenstore/blockstore.cpp b/src/zenstore/blockstore.cpp
index 63c0388fa..7cc09be15 100644
--- a/src/zenstore/blockstore.cpp
+++ b/src/zenstore/blockstore.cpp
@@ -85,7 +85,7 @@ BlockStoreFile::Create(uint64_t InitialSize)
 	ZEN_TRACE_CPU("BlockStoreFile::Create");
 
 	auto ParentPath = m_Path.parent_path();
-	if (!std::filesystem::is_directory(ParentPath))
+	if (!IsDir(ParentPath))
 	{
 		CreateDirectories(ParentPath);
 	}
@@ -215,7 +215,7 @@ IsMetaDataValid(const std::filesystem::path& BlockPath, const std::filesystem::p
 	}
 	if (MetaWriteTime < BlockWriteTime)
 	{
-		std::filesystem::remove(MetaPath, Ec);
+		RemoveFile(MetaPath, Ec);
 		return false;
 	}
 	return true;
@@ -239,7 +239,7 @@ BlockStoreFile::MetaSize() const
 	if (IsMetaDataValid(m_Path, MetaPath))
 	{
 		std::error_code DummyEc;
-		if (uint64_t Size = std::filesystem::file_size(MetaPath, DummyEc); !DummyEc)
+		if (uint64_t Size = FileSizeFromPath(MetaPath, DummyEc); !DummyEc)
 		{
 			return Size;
 		}
@@ -252,7 +252,7 @@ BlockStoreFile::RemoveMeta()
 {
 	std::filesystem::path MetaPath = GetMetaPath();
 	std::error_code		  DummyEc;
-	std::filesystem::remove(MetaPath, DummyEc);
+	RemoveFile(MetaPath, DummyEc);
 }
 
 std::filesystem::path
@@ -291,7 +291,7 @@ BlockStore::Initialize(const std::filesystem::path& BlocksBasePath, uint64_t Max
 	m_MaxBlockSize	 = MaxBlockSize;
 	m_MaxBlockCount	 = MaxBlockCount;
 
-	if (std::filesystem::is_directory(m_BlocksBasePath))
+	if (IsDir(m_BlocksBasePath))
 	{
 		uint32_t						   NextBlockIndex = 0;
 		std::vector<std::filesystem::path> FoldersToScan;
@@ -500,7 +500,7 @@ BlockStore::GetFreeBlockIndex(uint32_t ProbeIndex, RwLock::ExclusiveLockScope&,
 		{
 			OutBlockPath = GetBlockPath(m_BlocksBasePath, ProbeIndex);
 			std::error_code Ec;
-			bool			Exists = std::filesystem::exists(OutBlockPath, Ec);
+			bool			Exists = IsFile(OutBlockPath, Ec);
 			if (Ec)
 			{
 				ZEN_WARN("Failed to probe existence of file '{}' when trying to allocate a new block. Reason: '{}'",
@@ -1375,14 +1375,14 @@ TEST_CASE("blockstore.blockfile")
 			BoopChunk = File1.GetChunk(5, 5);
 		}
 
-		CHECK(std::filesystem::exists(RootDirectory / "1"));
+		CHECK(IsFile(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"));
+	CHECK(IsFile(RootDirectory / "1"));
 
 	{
 		IoBuffer DataChunk;
@@ -1401,7 +1401,7 @@ TEST_CASE("blockstore.blockfile")
 		const char* Boop = static_cast<const char*>(BoopChunk.GetData());
 		CHECK(std::string(Boop) == "boop");
 	}
-	CHECK(!std::filesystem::exists(RootDirectory / "1"));
+	CHECK(!IsFile(RootDirectory / "1"));
 }
 
 namespace blockstore::impl {
diff --git a/src/zenstore/buildstore/buildstore.cpp b/src/zenstore/buildstore/buildstore.cpp
index eb36be049..f26901458 100644
--- a/src/zenstore/buildstore/buildstore.cpp
+++ b/src/zenstore/buildstore/buildstore.cpp
@@ -71,7 +71,7 @@ BuildStore::BuildStore(const BuildStoreConfig& Config, GcManager& Gc)
 	{
 		std::filesystem::path BlobLogPath = blobstore::impl::GetBlobLogPath(Config.RootDirectory);
 		std::filesystem::path MetaLogPath = blobstore::impl::GetMetaLogPath(Config.RootDirectory);
-		bool				  IsNew		  = !(std::filesystem::exists(BlobLogPath) && std::filesystem::exists(MetaLogPath));
+		bool				  IsNew		  = !(IsFile(BlobLogPath) && IsFile(MetaLogPath));
 
 		if (!IsNew)
 		{
@@ -501,7 +501,7 @@ uint64_t
 BuildStore::ReadPayloadLog(const RwLock::ExclusiveLockScope&, const std::filesystem::path& LogPath, uint64_t SkipEntryCount)
 {
 	ZEN_TRACE_CPU("BuildStore::ReadPayloadLog");
-	if (!std::filesystem::is_regular_file(LogPath))
+	if (!IsFile(LogPath))
 	{
 		return 0;
 	}
@@ -518,7 +518,7 @@ BuildStore::ReadPayloadLog(const RwLock::ExclusiveLockScope&, const std::filesys
 	TCasLogFile<PayloadDiskEntry> CasLog;
 	if (!CasLog.IsValid(LogPath))
 	{
-		std::filesystem::remove(LogPath);
+		RemoveFile(LogPath);
 		return 0;
 	}
 	CasLog.Open(LogPath, CasLogFile::Mode::kRead);
@@ -603,7 +603,7 @@ uint64_t
 BuildStore::ReadMetadataLog(const RwLock::ExclusiveLockScope&, const std::filesystem::path& LogPath, uint64_t SkipEntryCount)
 {
 	ZEN_TRACE_CPU("BuildStore::ReadMetadataLog");
-	if (!std::filesystem::is_regular_file(LogPath))
+	if (!IsFile(LogPath))
 	{
 		return 0;
 	}
@@ -620,7 +620,7 @@ BuildStore::ReadMetadataLog(const RwLock::ExclusiveLockScope&, const std::filesy
 	TCasLogFile<MetadataDiskEntry> CasLog;
 	if (!CasLog.IsValid(LogPath))
 	{
-		std::filesystem::remove(LogPath);
+		RemoveFile(LogPath);
 		return 0;
 	}
 	CasLog.Open(LogPath, CasLogFile::Mode::kRead);
diff --git a/src/zenstore/cache/cachedisklayer.cpp b/src/zenstore/cache/cachedisklayer.cpp
index 61552fafc..b2d2416be 100644
--- a/src/zenstore/cache/cachedisklayer.cpp
+++ b/src/zenstore/cache/cachedisklayer.cpp
@@ -200,21 +200,21 @@ namespace cache::impl {
 		int DropIndex = 0;
 		do
 		{
-			if (!std::filesystem::exists(Dir))
+			if (!IsDir(Dir))
 			{
 				return false;
 			}
 
 			std::string			  DroppedName		= fmt::format("[dropped]{}({})", Dir.filename().string(), DropIndex);
 			std::filesystem::path DroppedBucketPath = Dir.parent_path() / DroppedName;
-			if (std::filesystem::exists(DroppedBucketPath))
+			if (IsDir(DroppedBucketPath))
 			{
 				DropIndex++;
 				continue;
 			}
 
 			std::error_code Ec;
-			std::filesystem::rename(Dir, DroppedBucketPath, Ec);
+			RenameDirectory(Dir, DroppedBucketPath, Ec);
 			if (!Ec)
 			{
 				DeleteDirectories(DroppedBucketPath);
@@ -909,16 +909,16 @@ ZenCacheDiskLayer::CacheBucket::WriteIndexSnapshotLocked(bool FlushLockPosition,
 			{
 				std::filesystem::path LogPath = cache::impl::GetLogPath(m_BucketDir, m_BucketName);
 
-				if (std::filesystem::is_regular_file(LogPath))
+				if (IsFile(LogPath))
 				{
-					if (!std::filesystem::remove(LogPath, Ec) || Ec)
+					if (!RemoveFile(LogPath, Ec) || Ec)
 					{
 						ZEN_WARN("snapshot failed to clean log file '{}', removing index at '{}', reason: '{}'",
 								 LogPath,
 								 IndexPath,
 								 Ec.message());
 						std::error_code RemoveIndexEc;
-						std::filesystem::remove(IndexPath, RemoveIndexEc);
+						RemoveFile(IndexPath, RemoveIndexEc);
 					}
 				}
 			}
@@ -939,7 +939,7 @@ ZenCacheDiskLayer::CacheBucket::ReadIndexFile(RwLock::ExclusiveLockScope&, const
 {
 	ZEN_TRACE_CPU("Z$::Bucket::ReadIndexFile");
 
-	if (!std::filesystem::is_regular_file(IndexPath))
+	if (!IsFile(IndexPath))
 	{
 		return 0;
 	}
@@ -1023,7 +1023,7 @@ ZenCacheDiskLayer::CacheBucket::ReadLog(RwLock::ExclusiveLockScope&, const std::
 {
 	ZEN_TRACE_CPU("Z$::Bucket::ReadLog");
 
-	if (!std::filesystem::is_regular_file(LogPath))
+	if (!IsFile(LogPath))
 	{
 		return 0;
 	}
@@ -1103,37 +1103,37 @@ ZenCacheDiskLayer::CacheBucket::InitializeIndexFromDisk(RwLock::ExclusiveLockSco
 
 	if (IsNew)
 	{
-		fs::remove(LogPath);
-		fs::remove(IndexPath);
-		fs::remove_all(m_BlocksBasePath);
+		RemoveFile(LogPath);
+		RemoveFile(IndexPath);
+		DeleteDirectories(m_BlocksBasePath);
 	}
 
 	CreateDirectories(m_BucketDir);
 
 	m_BlockStore.Initialize(m_BlocksBasePath, m_Configuration.MaxBlockSize, BlockStoreDiskLocation::MaxBlockIndex + 1);
 
-	if (std::filesystem::is_regular_file(IndexPath))
+	if (IsFile(IndexPath))
 	{
 		uint32_t IndexVersion = 0;
 		m_LogFlushPosition	  = ReadIndexFile(IndexLock, IndexPath, IndexVersion);
 		if (IndexVersion == 0)
 		{
 			ZEN_WARN("removing invalid index file at '{}'", IndexPath);
-			std::filesystem::remove(IndexPath);
+			RemoveFile(IndexPath);
 		}
 	}
 
 	uint64_t LogEntryCount = 0;
-	if (std::filesystem::is_regular_file(LogPath))
+	if (IsFile(LogPath))
 	{
 		if (TCasLogFile<DiskIndexEntry>::IsValid(LogPath))
 		{
 			LogEntryCount = ReadLog(IndexLock, LogPath, m_LogFlushPosition);
 		}
-		else if (fs::is_regular_file(LogPath))
+		else if (IsFile(LogPath))
 		{
 			ZEN_WARN("removing invalid log at '{}'", LogPath);
-			std::filesystem::remove(LogPath);
+			RemoveFile(LogPath);
 		}
 	}
 
@@ -2146,7 +2146,7 @@ ZenCacheDiskLayer::CacheBucket::ScrubStorage(ScrubContext& Ctx)
 					RwLock::SharedLockScope ValueLock(LockForHash(HashKey));
 
 					std::error_code Ec;
-					uintmax_t		size = std::filesystem::file_size(DataFilePath.ToPath(), Ec);
+					uintmax_t		size = FileSizeFromPath(DataFilePath.ToPath(), Ec);
 					if (Ec)
 					{
 						ReportBadKey(HashKey);
@@ -2287,11 +2287,11 @@ ZenCacheDiskLayer::CacheBucket::ScrubStorage(ScrubContext& Ctx)
 					BuildPath(Path, Entry.Key);
 					fs::path				   FilePath = Path.ToPath();
 					RwLock::ExclusiveLockScope ValueLock(LockForHash(Entry.Key));
-					if (fs::is_regular_file(FilePath))
+					if (IsFile(FilePath))
 					{
 						ZEN_DEBUG("deleting bad standalone cache file '{}'", Path.ToUtf8());
 						std::error_code Ec;
-						fs::remove(FilePath, Ec);  // We don't care if we fail, we are no longer tracking this file...
+						RemoveFile(FilePath, Ec);  // We don't care if we fail, we are no longer tracking this file...
 					}
 				}
 			}
@@ -2424,7 +2424,7 @@ ZenCacheDiskLayer::CacheBucket::PutStandaloneCacheValue(const IoHash& HashKey, c
 		 if (CleanUpTempFile)
 		 {
 			 std::error_code Ec;
-			 std::filesystem::remove(DataFile.GetPath(), Ec);
+			 RemoveFile(DataFile.GetPath(), Ec);
 			 if (Ec)
 			 {
 				 ZEN_WARN("Failed to clean up temporary file '{}' for put in '{}', reason '{}'",
@@ -2452,7 +2452,7 @@ ZenCacheDiskLayer::CacheBucket::PutStandaloneCacheValue(const IoHash& HashKey, c
 	RwLock::ExclusiveLockScope ValueLock(LockForHash(HashKey));
 
 	// We do a speculative remove of the file instead of probing with a exists call and check the error code instead
-	std::filesystem::remove(FsPath, Ec);
+	RemoveFile(FsPath, Ec);
 	if (Ec)
 	{
 		if (Ec.value() != ENOENT)
@@ -2460,7 +2460,7 @@ ZenCacheDiskLayer::CacheBucket::PutStandaloneCacheValue(const IoHash& HashKey, c
 			ZEN_WARN("Failed to remove file '{}' for put in '{}', reason: '{}', retrying.", FsPath, m_BucketDir, Ec.message());
 			Sleep(100);
 			Ec.clear();
-			std::filesystem::remove(FsPath, Ec);
+			RemoveFile(FsPath, Ec);
 			if (Ec && Ec.value() != ENOENT)
 			{
 				throw std::system_error(Ec, fmt::format("Failed to remove file '{}' for put in '{}'", FsPath, m_BucketDir));
@@ -2791,7 +2791,7 @@ public:
 					ZEN_DEBUG("GCV2: cachebucket [COMPACT] '{}': deleting standalone cache file '{}'", m_Bucket.m_BucketDir, Path.ToUtf8());
 
 					std::error_code Ec;
-					if (!fs::remove(FilePath, Ec))
+					if (!RemoveFile(FilePath, Ec))
 					{
 						continue;
 					}
@@ -2812,7 +2812,7 @@ public:
 					ZEN_DEBUG("GCV2: cachebucket [COMPACT] '{}': checking standalone cache file '{}'", m_Bucket.m_BucketDir, Path.ToUtf8());
 
 					std::error_code Ec;
-					bool			Existed = std::filesystem::is_regular_file(FilePath, Ec);
+					bool			Existed = IsFile(FilePath, Ec);
 					if (Ec)
 					{
 						ZEN_WARN("GCV2: cachebucket [COMPACT] '{}': failed checking cache payload file '{}'. Reason '{}'",
diff --git a/src/zenstore/cas.cpp b/src/zenstore/cas.cpp
index 73c10a6db..ed42f254e 100644
--- a/src/zenstore/cas.cpp
+++ b/src/zenstore/cas.cpp
@@ -118,7 +118,7 @@ CasImpl::Initialize(const CidStoreConfiguration& InConfig)
 
 	// Ensure root directory exists - create if it doesn't exist already
 
-	std::filesystem::create_directories(m_Config.RootDirectory);
+	CreateDirectories(m_Config.RootDirectory);
 
 	// Open or create manifest
 
diff --git a/src/zenstore/caslog.cpp b/src/zenstore/caslog.cpp
index 6c7b1b297..492ce9317 100644
--- a/src/zenstore/caslog.cpp
+++ b/src/zenstore/caslog.cpp
@@ -37,7 +37,7 @@ CasLogFile::~CasLogFile()
 bool
 CasLogFile::IsValid(std::filesystem::path FileName, size_t RecordSize)
 {
-	if (!std::filesystem::is_regular_file(FileName))
+	if (!IsFile(FileName))
 	{
 		return false;
 	}
diff --git a/src/zenstore/compactcas.cpp b/src/zenstore/compactcas.cpp
index b64bc26dd..184251da7 100644
--- a/src/zenstore/compactcas.cpp
+++ b/src/zenstore/compactcas.cpp
@@ -927,10 +927,10 @@ CasContainerStrategy::MakeIndexSnapshot()
 	fs::path TempIndexPath = cas::impl::GetTempIndexPath(m_RootDirectory, m_ContainerBaseName);
 
 	// Move index away, we keep it if something goes wrong
-	if (fs::is_regular_file(TempIndexPath))
+	if (IsFile(TempIndexPath))
 	{
 		std::error_code Ec;
-		if (!fs::remove(TempIndexPath, Ec) || Ec)
+		if (!RemoveFile(TempIndexPath, Ec) || Ec)
 		{
 			ZEN_WARN("snapshot failed to clean up temp snapshot at {}, reason: '{}'", TempIndexPath, Ec.message());
 			return;
@@ -939,9 +939,9 @@ CasContainerStrategy::MakeIndexSnapshot()
 
 	try
 	{
-		if (fs::is_regular_file(IndexPath))
+		if (IsFile(IndexPath))
 		{
-			fs::rename(IndexPath, TempIndexPath);
+			RenameFile(IndexPath, TempIndexPath);
 		}
 
 		// Write the current state of the location map to a new index state
@@ -992,21 +992,21 @@ CasContainerStrategy::MakeIndexSnapshot()
 
 		// Restore any previous snapshot
 
-		if (fs::is_regular_file(TempIndexPath))
+		if (IsFile(TempIndexPath))
 		{
 			std::error_code Ec;
-			fs::remove(IndexPath, Ec);	// We don't care if this fails, we try to move the old temp file regardless
-			fs::rename(TempIndexPath, IndexPath, Ec);
+			RemoveFile(IndexPath, Ec);	// We don't care if this fails, we try to move the old temp file regardless
+			RenameFile(TempIndexPath, IndexPath, Ec);
 			if (Ec)
 			{
 				ZEN_WARN("snapshot failed to restore old snapshot from {}, reason: '{}'", TempIndexPath, Ec.message());
 			}
 		}
 	}
-	if (fs::is_regular_file(TempIndexPath))
+	if (IsFile(TempIndexPath))
 	{
 		std::error_code Ec;
-		if (!fs::remove(TempIndexPath, Ec) || Ec)
+		if (!RemoveFile(TempIndexPath, Ec) || Ec)
 		{
 			ZEN_WARN("snapshot failed to remove temporary file {}, reason: '{}'", TempIndexPath, Ec.message());
 		}
@@ -1092,7 +1092,7 @@ CasContainerStrategy::ReadLog(const std::filesystem::path& LogPath, uint64_t Ski
 	if (!TCasLogFile<CasDiskIndexEntry>::IsValid(LogPath))
 	{
 		ZEN_WARN("removing invalid cas log at '{}'", LogPath);
-		std::filesystem::remove(LogPath);
+		RemoveFile(LogPath);
 		return 0;
 	}
 
@@ -1155,7 +1155,7 @@ CasContainerStrategy::OpenContainer(bool IsNewStore)
 
 	if (IsNewStore)
 	{
-		std::filesystem::remove_all(BasePath);
+		DeleteDirectories(BasePath);
 	}
 
 	CreateDirectories(BasePath);
@@ -1165,19 +1165,19 @@ CasContainerStrategy::OpenContainer(bool IsNewStore)
 	std::filesystem::path LogPath	= cas::impl::GetLogPath(m_RootDirectory, m_ContainerBaseName);
 	std::filesystem::path IndexPath = cas::impl::GetIndexPath(m_RootDirectory, m_ContainerBaseName);
 
-	if (std::filesystem::is_regular_file(IndexPath))
+	if (IsFile(IndexPath))
 	{
 		uint32_t IndexVersion = 0;
 		m_LogFlushPosition	  = ReadIndexFile(IndexPath, IndexVersion);
 		if (IndexVersion == 0)
 		{
 			ZEN_WARN("removing invalid index file at '{}'", IndexPath);
-			std::filesystem::remove(IndexPath);
+			RemoveFile(IndexPath);
 		}
 	}
 
 	uint64_t LogEntryCount = 0;
-	if (std::filesystem::is_regular_file(LogPath))
+	if (IsFile(LogPath))
 	{
 		if (TCasLogFile<CasDiskIndexEntry>::IsValid(LogPath))
 		{
@@ -1186,7 +1186,7 @@ CasContainerStrategy::OpenContainer(bool IsNewStore)
 		else
 		{
 			ZEN_WARN("removing invalid cas log at '{}'", LogPath);
-			std::filesystem::remove(LogPath);
+			RemoveFile(LogPath);
 		}
 	}
 
diff --git a/src/zenstore/filecas.cpp b/src/zenstore/filecas.cpp
index 34db51aa9..14bdc41f0 100644
--- a/src/zenstore/filecas.cpp
+++ b/src/zenstore/filecas.cpp
@@ -176,10 +176,10 @@ FileCasStrategy::Initialize(const std::filesystem::path& RootDirectory, bool IsN
 
 	if (IsNewStore)
 	{
-		std::filesystem::remove(LogPath);
-		std::filesystem::remove(IndexPath);
+		RemoveFile(LogPath);
+		RemoveFile(IndexPath);
 
-		if (std::filesystem::is_directory(m_RootDirectory))
+		if (IsDir(m_RootDirectory))
 		{
 			// We need to explicitly only delete sharded root folders as the cas manifest, tinyobject and smallobject cas folders may reside
 			// in this folder as well
@@ -211,24 +211,24 @@ FileCasStrategy::Initialize(const std::filesystem::path& RootDirectory, bool IsN
 			Traversal.TraverseFileSystem(m_RootDirectory, CasVisitor);
 			for (const std::filesystem::path& SharededRoot : CasVisitor.ShardedRoots)
 			{
-				std::filesystem::remove_all(SharededRoot);
+				DeleteDirectories(SharededRoot);
 			}
 		}
 	}
 
-	if (std::filesystem::is_regular_file(IndexPath))
+	if (IsFile(IndexPath))
 	{
 		uint32_t IndexVersion = 0;
 		m_LogFlushPosition	  = ReadIndexFile(IndexPath, IndexVersion);
 		if (IndexVersion == 0)
 		{
 			ZEN_WARN("removing invalid index file at '{}'", IndexPath);
-			std::filesystem::remove(IndexPath);
+			RemoveFile(IndexPath);
 		}
 	}
 
 	uint64_t LogEntryCount = 0;
-	if (std::filesystem::is_regular_file(LogPath))
+	if (IsFile(LogPath))
 	{
 		if (TCasLogFile<FileCasIndexEntry>::IsValid(LogPath))
 		{
@@ -237,7 +237,7 @@ FileCasStrategy::Initialize(const std::filesystem::path& RootDirectory, bool IsN
 		else
 		{
 			ZEN_WARN("removing invalid cas log at '{}'", LogPath);
-			std::filesystem::remove(LogPath);
+			RemoveFile(LogPath);
 		}
 	}
 
@@ -327,7 +327,7 @@ FileCasStrategy::InsertChunk(IoBuffer Chunk, const IoHash& ChunkHash, CasStore::
 	{
 		std::filesystem::path TempPath(ChunkPath.parent_path() / Oid::NewOid().ToString());
 		std::error_code		  Ec;
-		std::filesystem::rename(ChunkPath, TempPath, Ec);
+		RenameFile(ChunkPath, TempPath, Ec);
 		if (Ec)
 		{
 			throw std::system_error(Ec, fmt::format("unable to move existing CAS file {} to {}", ChunkPath, TempPath));
@@ -452,7 +452,7 @@ FileCasStrategy::InsertChunk(IoBuffer Chunk, const IoHash& ChunkHash, CasStore::
 	{
 		PayloadFile.Close();
 		std::error_code DummyEc;
-		std::filesystem::remove(ChunkPath, DummyEc);
+		RemoveFile(ChunkPath, DummyEc);
 		throw;
 	}
 	bool IsNew = UpdateIndex(ChunkHash, Chunk.Size());
@@ -503,7 +503,7 @@ FileCasStrategy::SafeOpenChunk(const IoHash& ChunkHash, uint64 ExpectedSize)
 		{
 			std::error_code		  Ec;
 			std::filesystem::path TempPath(ChunkPath.parent_path() / Oid::NewOid().ToString());
-			std::filesystem::rename(ChunkPath, TempPath, Ec);
+			RenameFile(ChunkPath, TempPath, Ec);
 			if (!Ec)
 			{
 				Chunk.SetDeleteOnClose(true);
@@ -574,7 +574,7 @@ FileCasStrategy::DeleteChunk(const IoHash& ChunkHash, std::error_code& Ec)
 
 	ShardingHelper				Name(m_RootDirectory, ChunkHash);
 	const std::filesystem::path ChunkPath = Name.ShardedPath.ToPath();
-	uint64_t					FileSize  = static_cast<uint64_t>(std::filesystem::file_size(ChunkPath, Ec));
+	uint64_t					FileSize  = static_cast<uint64_t>(FileSizeFromPath(ChunkPath, Ec));
 	if (Ec)
 	{
 		ZEN_WARN("get file size FAILED, file cas '{}'", ChunkPath);
@@ -582,9 +582,9 @@ FileCasStrategy::DeleteChunk(const IoHash& ChunkHash, std::error_code& Ec)
 	}
 
 	ZEN_DEBUG("deleting CAS payload file '{}' {}", ChunkPath, NiceBytes(FileSize));
-	std::filesystem::remove(ChunkPath, Ec);
+	RemoveFile(ChunkPath, Ec);
 
-	if (!Ec || !std::filesystem::exists(ChunkPath))
+	if (!Ec || !IsFile(ChunkPath))
 	{
 		{
 			RwLock::ExclusiveLockScope _(m_Lock);
@@ -941,10 +941,10 @@ FileCasStrategy::MakeIndexSnapshot()
 	fs::path STmpIndexPath = GetTempIndexPath(m_RootDirectory);
 
 	// Move index away, we keep it if something goes wrong
-	if (fs::is_regular_file(STmpIndexPath))
+	if (IsFile(STmpIndexPath))
 	{
 		std::error_code Ec;
-		if (!fs::remove(STmpIndexPath, Ec) || Ec)
+		if (!RemoveFile(STmpIndexPath, Ec) || Ec)
 		{
 			ZEN_WARN("snapshot failed to clean up temp snapshot at {}, reason: '{}'", STmpIndexPath, Ec.message());
 			return;
@@ -953,9 +953,9 @@ FileCasStrategy::MakeIndexSnapshot()
 
 	try
 	{
-		if (fs::is_regular_file(IndexPath))
+		if (IsFile(IndexPath))
 		{
-			fs::rename(IndexPath, STmpIndexPath);
+			RenameFile(IndexPath, STmpIndexPath);
 		}
 
 		// Write the current state of the location map to a new index state
@@ -1004,21 +1004,21 @@ FileCasStrategy::MakeIndexSnapshot()
 
 		// Restore any previous snapshot
 
-		if (fs::is_regular_file(STmpIndexPath))
+		if (IsFile(STmpIndexPath))
 		{
 			std::error_code Ec;
-			fs::remove(IndexPath, Ec);	// We don't care if this fails, we try to move the old temp file regardless
-			fs::rename(STmpIndexPath, IndexPath, Ec);
+			RemoveFile(IndexPath, Ec);	// We don't care if this fails, we try to move the old temp file regardless
+			RenameFile(STmpIndexPath, IndexPath, Ec);
 			if (Ec)
 			{
 				ZEN_WARN("snapshot failed to restore old snapshot from {}, reason: '{}'", STmpIndexPath, Ec.message());
 			}
 		}
 	}
-	if (fs::is_regular_file(STmpIndexPath))
+	if (IsFile(STmpIndexPath))
 	{
 		std::error_code Ec;
-		if (!fs::remove(STmpIndexPath, Ec) || Ec)
+		if (!RemoveFile(STmpIndexPath, Ec) || Ec)
 		{
 			ZEN_WARN("snapshot failed to remove temporary file {}, reason: '{}'", STmpIndexPath, Ec.message());
 		}
@@ -1032,7 +1032,7 @@ FileCasStrategy::ReadIndexFile(const std::filesystem::path& IndexPath, uint32_t&
 	using namespace filecas::impl;
 
 	std::vector<FileCasIndexEntry> Entries;
-	if (std::filesystem::is_regular_file(IndexPath))
+	if (IsFile(IndexPath))
 	{
 		Stopwatch  Timer;
 		const auto _ = MakeGuard([&] {
@@ -1077,7 +1077,7 @@ FileCasStrategy::ReadIndexFile(const std::filesystem::path& IndexPath, uint32_t&
 		return 0;
 	}
 
-	if (std::filesystem::is_directory(m_RootDirectory))
+	if (IsDir(m_RootDirectory))
 	{
 		ZEN_INFO("missing index for file cas, scanning for cas files in {}", m_RootDirectory);
 		TCasLogFile<FileCasIndexEntry> CasLog;
@@ -1116,7 +1116,7 @@ FileCasStrategy::ReadLog(const std::filesystem::path& LogPath, uint64_t SkipEntr
 
 	using namespace filecas::impl;
 
-	if (std::filesystem::is_regular_file(LogPath))
+	if (IsFile(LogPath))
 	{
 		uint64_t					   LogEntryCount = 0;
 		Stopwatch					   Timer;
@@ -1274,12 +1274,12 @@ public:
 								 ChunkPath);
 					}
 					std::error_code Ec;
-					uint64_t		SizeOnDisk = std::filesystem::file_size(ChunkPath, Ec);
+					uint64_t		SizeOnDisk = FileSizeFromPath(ChunkPath, Ec);
 					if (Ec)
 					{
 						SizeOnDisk = 0;
 					}
-					bool Existed = std::filesystem::remove(ChunkPath, Ec);
+					bool Existed = RemoveFile(ChunkPath, Ec);
 					if (Ec)
 					{
 						// Target file may be open for read, attempt to move it to a temp file and mark it delete on close
@@ -1290,7 +1290,7 @@ public:
 						if (OldChunk)
 						{
 							std::filesystem::path TempPath(ChunkPath.parent_path() / Oid::NewOid().ToString());
-							std::filesystem::rename(ChunkPath, TempPath, Ec);
+							RenameFile(ChunkPath, TempPath, Ec);
 							if (!Ec)
 							{
 								OldChunk.SetDeleteOnClose(true);
@@ -1317,7 +1317,7 @@ public:
 				else
 				{
 					std::error_code Ec;
-					bool			Existed = std::filesystem::is_regular_file(ChunkPath, Ec);
+					bool			Existed = IsFile(ChunkPath, Ec);
 					if (Ec)
 					{
 						if (Ctx.Settings.Verbose)
@@ -1516,7 +1516,7 @@ TEST_CASE("cas.chunk.moveoverwrite")
 			Payload1.SetDeleteOnClose(true);
 			CasStore::InsertResult Result = FileCas.InsertChunk(Payload1, CompressedPayload1.DecodeRawHash());
 			CHECK_EQ(Result.New, true);
-			CHECK(!std::filesystem::exists(Payload1Path));
+			CHECK(!IsFile(Payload1Path));
 		}
 		{
 			std::filesystem::path Payload1BPath{TempDir.Path() / "payload_1"};
@@ -1526,9 +1526,9 @@ TEST_CASE("cas.chunk.moveoverwrite")
 
 			CasStore::InsertResult Result = FileCas.InsertChunk(Payload1B, CompressedPayload1.DecodeRawHash());
 			CHECK_EQ(Result.New, false);
-			CHECK(std::filesystem::exists(Payload1BPath));
+			CHECK(IsFile(Payload1BPath));
 			Payload1B = {};
-			CHECK(!std::filesystem::exists(Payload1BPath));
+			CHECK(!IsFile(Payload1BPath));
 		}
 
 		IoBuffer FetchedPayload = FileCas.FindChunk(CompressedPayload1.DecodeRawHash());
@@ -1554,7 +1554,7 @@ TEST_CASE("cas.chunk.moveoverwrite")
 		}
 
 		Payload2 = {};
-		CHECK(!std::filesystem::exists(Payload2Path));
+		CHECK(!IsFile(Payload2Path));
 
 		{
 			IoHash			 RawHash;
@@ -1598,9 +1598,9 @@ TEST_CASE("cas.chunk.copyoverwrite")
 			CasStore::InsertResult Result =
 				FileCas.InsertChunk(Payload1, CompressedPayload1.DecodeRawHash(), CasStore::InsertMode::kCopyOnly);
 			CHECK_EQ(Result.New, true);
-			CHECK(std::filesystem::exists(Payload1Path));
+			CHECK(IsFile(Payload1Path));
 			Payload1 = {};
-			CHECK(!std::filesystem::exists(Payload1Path));
+			CHECK(!IsFile(Payload1Path));
 		}
 		{
 			std::filesystem::path Payload1BPath{TempDir.Path() / "payload_1"};
@@ -1611,9 +1611,9 @@ TEST_CASE("cas.chunk.copyoverwrite")
 			CasStore::InsertResult Result =
 				FileCas.InsertChunk(Payload1B, CompressedPayload1.DecodeRawHash(), CasStore::InsertMode::kCopyOnly);
 			CHECK_EQ(Result.New, false);
-			CHECK(std::filesystem::exists(Payload1BPath));
+			CHECK(IsFile(Payload1BPath));
 			Payload1B = {};
-			CHECK(!std::filesystem::exists(Payload1BPath));
+			CHECK(!IsFile(Payload1BPath));
 		}
 
 		IoBuffer FetchedPayload = FileCas.FindChunk(CompressedPayload1.DecodeRawHash());
@@ -1640,7 +1640,7 @@ TEST_CASE("cas.chunk.copyoverwrite")
 		}
 
 		Payload2 = {};
-		CHECK(!std::filesystem::exists(Payload2Path));
+		CHECK(!IsFile(Payload2Path));
 
 		{
 			IoHash			 RawHash;
diff --git a/src/zenstore/gc.cpp b/src/zenstore/gc.cpp
index fe5ae284b..ac4dda83f 100644
--- a/src/zenstore/gc.cpp
+++ b/src/zenstore/gc.cpp
@@ -62,11 +62,11 @@ namespace {
 	{
 		if (Size == 0)
 		{
-			std::filesystem::remove(Path);
+			RemoveFile(Path);
 			return std::error_code{};
 		}
 		CreateDirectories(Path.parent_path());
-		if (std::filesystem::is_regular_file(Path) && std::filesystem::file_size(Path) == Size)
+		if (IsFile(Path) && FileSizeFromPath(Path) == Size)
 		{
 			return std::error_code();
 		}
@@ -1262,12 +1262,12 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 			ZEN_TRACE_CPU("GcV2::CompactStores");
 
 			auto ClaimDiskReserve = [&]() -> uint64_t {
-				if (!std::filesystem::is_regular_file(Settings.DiskReservePath))
+				if (!IsFile(Settings.DiskReservePath))
 				{
 					return 0;
 				}
-				uint64_t ReclaimedSize = std::filesystem::file_size(Settings.DiskReservePath);
-				if (std::filesystem::remove(Settings.DiskReservePath))
+				uint64_t ReclaimedSize = FileSizeFromPath(Settings.DiskReservePath);
+				if (RemoveFile(Settings.DiskReservePath))
 				{
 					return ReclaimedSize;
 				}
@@ -1557,7 +1557,7 @@ GcScheduler::Initialize(const GcSchedulerConfig& Config)
 		m_Config.LightweightInterval = m_Config.MonitorInterval;
 	}
 
-	std::filesystem::create_directories(Config.RootDirectory);
+	CreateDirectories(Config.RootDirectory);
 
 	std::error_code Ec = CreateGCReserve(m_Config.RootDirectory / "reserve.gc", m_Config.DiskReserveSize);
 	if (Ec)
@@ -1850,7 +1850,7 @@ GcScheduler::GetState() const
 	if (Result.Config.DiskReserveSize != 0)
 	{
 		Ec.clear();
-		Result.HasDiskReserve = std::filesystem::is_regular_file(Result.Config.RootDirectory / "reserve.gc", Ec) && !Ec;
+		Result.HasDiskReserve = IsFile(Result.Config.RootDirectory / "reserve.gc", Ec) && !Ec;
 	}
 
 	if (Result.Status != GcSchedulerStatus::kRunning)
@@ -2389,12 +2389,12 @@ GcScheduler::CollectGarbage(const GcClock::TimePoint& CacheExpireTime,
 		{
 			// We are low on disk, check if we can release our extra storage reserve, if we can't bail from doing GC
 			auto ClaimDiskReserve = [&]() -> uint64_t {
-				if (!std::filesystem::is_regular_file(DiskReservePath))
+				if (!IsFile(DiskReservePath))
 				{
 					return 0;
 				}
-				uint64_t ReclaimedSize = std::filesystem::file_size(DiskReservePath);
-				if (std::filesystem::remove(DiskReservePath))
+				uint64_t ReclaimedSize = FileSizeFromPath(DiskReservePath);
+				if (RemoveFile(DiskReservePath))
 				{
 					return ReclaimedSize;
 				}
diff --git a/src/zenstore/workspaces.cpp b/src/zenstore/workspaces.cpp
index 02a83d2a6..0ca2adab2 100644
--- a/src/zenstore/workspaces.cpp
+++ b/src/zenstore/workspaces.cpp
@@ -444,7 +444,7 @@ Workspaces::RefreshWorkspaceShares(const Oid& WorkspaceId)
 	{
 		const std::filesystem::path& RootPath	= Workspace->GetConfig().RootPath;
 		std::filesystem::path		 ConfigPath = RootPath / WorkspaceConfigName;
-		if (std::filesystem::exists(ConfigPath))
+		if (IsFile(ConfigPath))
 		{
 			std::string											 Error;
 			std::vector<Workspaces::WorkspaceShareConfiguration> WorkspaceShares = ReadWorkspaceConfig(m_Log, RootPath, Error);
@@ -458,7 +458,7 @@ Workspaces::RefreshWorkspaceShares(const Oid& WorkspaceId)
 				{
 					const std::filesystem::path& SharePath = Configuration.SharePath;
 
-					if (std::filesystem::is_directory(RootPath / SharePath))
+					if (IsDir(RootPath / SharePath))
 					{
 						DeletedShares.erase(Configuration.Id);
 
@@ -808,7 +808,7 @@ Workspaces::ReadConfig(const LoggerRef& InLog, const std::filesystem::path& Work
 	ZEN_DEBUG("Reading workspaces state from {}", WorkspaceStatePath);
 
 	const std::filesystem::path ConfigPath = WorkspaceStatePath / WorkspacesConfigName;
-	if (std::filesystem::exists(ConfigPath))
+	if (IsFile(ConfigPath))
 	{
 		std::vector<Workspaces::WorkspaceConfiguration> Workspaces =
 			WorkspacesFromJson(IoBufferBuilder::MakeFromFile(ConfigPath), OutError);
@@ -847,7 +847,7 @@ Workspaces::ReadWorkspaceConfig(const LoggerRef& InLog, const std::filesystem::p
 	ZEN_DEBUG("Reading workspace state from {}", WorkspaceRoot);
 
 	std::filesystem::path ConfigPath = WorkspaceRoot / WorkspaceConfigName;
-	if (std::filesystem::exists(ConfigPath))
+	if (IsFile(ConfigPath))
 	{
 		std::vector<Workspaces::WorkspaceShareConfiguration> WorkspaceShares =
 			WorkspaceSharesFromJson(IoBufferBuilder::MakeFromFile(ConfigPath), OutError);
@@ -886,7 +886,7 @@ Workspaces::AddWorkspace(const LoggerRef& Log, const std::filesystem::path& Work
 	{
 		throw std::invalid_argument(fmt::format("invalid root path '{}' for workspace {}", Configuration.RootPath, Configuration.Id));
 	}
-	if (!std::filesystem::is_directory(Configuration.RootPath))
+	if (!IsDir(Configuration.RootPath))
 	{
 		throw std::invalid_argument(
 			fmt::format("workspace root path '{}' does not exist for workspace '{}'", Configuration.RootPath, Configuration.Id));
@@ -965,7 +965,7 @@ Workspaces::AddWorkspaceShare(const LoggerRef&					 Log,
 		throw std::invalid_argument(
 			fmt::format("workspace share path '{}' is not a sub-path of workspace path '{}'", Configuration.SharePath, WorkspaceRoot));
 	}
-	if (!std::filesystem::is_directory(WorkspaceRoot / Configuration.SharePath))
+	if (!IsDir(WorkspaceRoot / Configuration.SharePath))
 	{
 		throw std::invalid_argument(
 			fmt::format("workspace share path '{}' does not exist in workspace path '{}'", Configuration.SharePath, WorkspaceRoot));
@@ -1244,7 +1244,7 @@ Workspaces::FindWorkspaceShare(const Oid& WorkspaceId, const Oid& ShareId, bool
 	const Workspaces::WorkspaceConfiguration&	   WorkspaceConfig = Workspace->GetConfig();
 	const Workspaces::WorkspaceShareConfiguration& ShareConfig	   = Share->GetConfig();
 	std::filesystem::path						   FullSharePath   = WorkspaceConfig.RootPath / ShareConfig.SharePath;
-	if (std::filesystem::is_directory(FullSharePath))
+	if (IsDir(FullSharePath))
 	{
 		if (ForceRefresh || !Share->IsInitialized())
 		{
@@ -1306,18 +1306,18 @@ namespace {
 		std::filesystem::path EmptyFolder(RootPath / "empty_folder");
 
 		std::filesystem::path FirstFolder(RootPath / "first_folder");
-		std::filesystem::create_directory(FirstFolder);
+		CreateDirectories(FirstFolder);
 		Result.push_back(std::make_pair(FirstFolder / "first_folder_blob1.bin", CreateRandomBlob(22)));
 		Result.push_back(std::make_pair(FirstFolder / "first_folder_blob2.bin", CreateRandomBlob(122)));
 
 		std::filesystem::path SecondFolder(RootPath / "second_folder");
-		std::filesystem::create_directory(SecondFolder);
+		CreateDirectories(SecondFolder);
 		Result.push_back(std::make_pair(SecondFolder / "second_folder_blob1.bin", CreateRandomBlob(522)));
 		Result.push_back(std::make_pair(SecondFolder / "second_folder_blob2.bin", CreateRandomBlob(122)));
 		Result.push_back(std::make_pair(SecondFolder / "second_folder_blob3.bin", CreateRandomBlob(225)));
 
 		std::filesystem::path SecondFolderChild(SecondFolder / "child_in_second");
-		std::filesystem::create_directory(SecondFolderChild);
+		CreateDirectories(SecondFolderChild);
 		Result.push_back(std::make_pair(SecondFolderChild / "second_child_folder_blob1.bin", CreateRandomBlob(622)));
 
 		for (const auto& It : Result)
@@ -1365,13 +1365,13 @@ TEST_CASE("workspaces.scanfolder")
 
 	Structure->IterateEntries([&](const Oid& Id, const FolderStructure::FileEntry& Entry) {
 		std::filesystem::path AbsPath = RootPath / Entry.RelativePath;
-		CHECK(std::filesystem::is_regular_file(AbsPath));
-		CHECK(std::filesystem::file_size(AbsPath) == Entry.Size);
+		CHECK(IsFile(AbsPath));
+		CHECK(FileSizeFromPath(AbsPath) == Entry.Size);
 		const FolderStructure::FileEntry* FindEntry = Structure->FindEntry(Id);
 		CHECK(FindEntry);
 		std::filesystem::path Path = RootPath / FindEntry->RelativePath;
 		CHECK(AbsPath == Path);
-		CHECK(std::filesystem::file_size(AbsPath) == FindEntry->Size);
+		CHECK(FileSizeFromPath(AbsPath) == FindEntry->Size);
 	});
 }