remove support for v1 recording

1 files changed, 1 insertions, 221 deletions

diff --git a/src/zenutil/cache/rpcrecording.cpp b/src/zenutil/cache/rpcrecording.cpp
index 93af1ff29..8e6728578 100644
--- a/src/zenutil/cache/rpcrecording.cpp
+++ b/src/zenutil/cache/rpcrecording.cpp
@@ -42,226 +42,6 @@ const RecordedRequestInfo RecordedRequestInfo::NullRequest = {.ContentType = Zen
 
 }
 
-namespace zen::cache::v1 {
-
-struct RecordedRequest
-{
-	uint64_t	   Offset;
-	uint64_t	   Length;
-	ZenContentType ContentType;
-	ZenContentType AcceptType;
-};
-
-const uint64_t RecordedRequestBlockSize	   = 1ull << 31u;
-const uint64_t StandaloneFileSizeThreshold = 1 * 1024 * 1024ull;
-
-struct RecordedRequestsWriter
-{
-	void BeginWrite(const std::filesystem::path& BasePath)
-	{
-		m_BasePath = BasePath;
-		CreateDirectories(m_BasePath);
-	}
-
-	void EndWrite()
-	{
-		RwLock::ExclusiveLockScope _(m_Lock);
-		m_BlockFiles.clear();
-
-		try
-		{
-			// Emit some metadata alongside the recording
-
-			DateTime EndTime = DateTime::Now();
-			TimeSpan Duration{EndTime.GetTicks() - m_StartTime.GetTicks()};
-
-			CbObjectWriter Cbo;
-			Cbo << "time_start" << m_StartTime << "time_end" << EndTime << "duration" << Duration;
-			Cbo << "entry_count" << m_Entries.size() << "entry_size" << sizeof(RecordedRequest);
-			Cbo << "block_size" << RecordedRequestBlockSize << "standalone_threshold" << StandaloneFileSizeThreshold;
-
-			Cbo.BeginObject("system_info");
-			Cbo << "host" << GetMachineName() << "os" << GetOperatingSystemName() << "cpu" << GetCpuName();
-			Describe(GetSystemMetrics(), Cbo);
-			Cbo.EndObject();
-			CbObject Metadata = Cbo.Save();
-
-			WriteFile(m_BasePath / "rpc_recording_metadata.zcb", Metadata.GetBuffer().AsIoBuffer());
-		}
-		catch (const std::exception& Ex)
-		{
-			ZEN_WARN("caught exception while generating metadata for RPC recording: {}", Ex.what());
-		}
-
-		IoBuffer  IndexBuffer(IoBuffer::Wrap, m_Entries.data(), m_Entries.size() * sizeof(RecordedRequest));
-		BasicFile IndexFile;
-		IndexFile.Open(m_BasePath / "index.bin", BasicFile::Mode::kTruncate);
-		std::error_code Ec;
-		IndexFile.WriteAll(IndexBuffer, Ec);
-		IndexFile.Close();
-		m_Entries.clear();
-	}
-
-	void WriteRequest(const RecordedRequestInfo& RequestInfo, const IoBuffer& RequestBuffer)
-	{
-		RwLock::ExclusiveLockScope Lock(m_Lock);
-		uint64_t				   RequestIndex = m_Entries.size();
-		RecordedRequest&		   Entry		= m_Entries.emplace_back(RecordedRequest{.Offset	  = ~0ull,
-																						 .Length	  = RequestBuffer.Size(),
-																						 .ContentType = RequestInfo.ContentType,
-																						 .AcceptType  = RequestInfo.AcceptType});
-
-		if (Entry.Length < StandaloneFileSizeThreshold)
-		{
-			const uint32_t BlockIndex = gsl::narrow<uint32_t>((m_ChunkOffset + Entry.Length) / RecordedRequestBlockSize);
-			if (BlockIndex == m_BlockFiles.size())
-			{
-				std::unique_ptr<BasicFile>& NewBlockFile = m_BlockFiles.emplace_back(std::make_unique<BasicFile>());
-				NewBlockFile->Open(m_BasePath / fmt::format("chunks{}.bin", BlockIndex), BasicFile::Mode::kTruncate);
-				m_ChunkOffset = BlockIndex * RecordedRequestBlockSize;
-			}
-			ZEN_ASSERT(BlockIndex < m_BlockFiles.size());
-			BasicFile* BlockFile = m_BlockFiles[BlockIndex].get();
-			ZEN_ASSERT(BlockFile != nullptr);
-
-			Entry.Offset  = m_ChunkOffset;
-			m_ChunkOffset = RoundUp(m_ChunkOffset + Entry.Length, 1u << 4u);
-			Lock.ReleaseNow();
-
-			std::error_code Ec;
-			BlockFile->Write(RequestBuffer.Data(), RequestBuffer.Size(), Entry.Offset - BlockIndex * RecordedRequestBlockSize, Ec);
-			if (Ec)
-			{
-				Entry.Length = 0;
-			}
-		}
-		else
-		{
-			Lock.ReleaseNow();
-
-			BasicFile RequestFile;
-			RequestFile.Open(m_BasePath / fmt::format("request{}.bin", RequestIndex), BasicFile::Mode::kTruncate);
-			std::error_code Ec;
-			RequestFile.WriteAll(RequestBuffer, Ec);
-			if (Ec)
-			{
-				Entry.Length = 0;
-			}
-		}
-	}
-
-	std::filesystem::path					m_BasePath;
-	mutable RwLock							m_Lock;
-	std::vector<RecordedRequest>			m_Entries;
-	std::vector<std::unique_ptr<BasicFile>> m_BlockFiles;
-	uint64_t								m_ChunkOffset;
-	zen::DateTime							m_StartTime = DateTime::Now();
-};
-
-struct RecordedRequestsReader
-{
-	uint64_t BeginRead(const std::filesystem::path& BasePath, bool InMemory)
-	{
-		m_BasePath = BasePath;
-		BasicFile IndexFile;
-		IndexFile.Open(m_BasePath / "index.bin", BasicFile::Mode::kRead);
-		m_Entries.resize(IndexFile.FileSize() / sizeof(RecordedRequest));
-		IndexFile.Read(m_Entries.data(), IndexFile.FileSize(), 0);
-		uint64_t MaxChunkPosition = 0;
-		for (const RecordedRequest& R : m_Entries)
-		{
-			if (R.Offset != ~0ull)
-			{
-				MaxChunkPosition = Max(MaxChunkPosition, R.Offset + R.Length);
-			}
-		}
-		uint32_t BlockCount = gsl::narrow<uint32_t>(MaxChunkPosition / RecordedRequestBlockSize) + 1;
-		m_BlockFiles.resize(BlockCount);
-		for (uint32_t BlockIndex = 0; BlockIndex < BlockCount; ++BlockIndex)
-		{
-			if (InMemory)
-			{
-				BasicFile Chunk;
-				Chunk.Open(m_BasePath / fmt::format("chunks{}.bin", BlockIndex), BasicFile::Mode::kRead);
-				m_BlockFiles[BlockIndex] = Chunk.ReadAll();
-				continue;
-			}
-			m_BlockFiles[BlockIndex] = IoBufferBuilder::MakeFromFile(m_BasePath / fmt::format("chunks{}.bin", BlockIndex));
-		}
-		return m_Entries.size();
-	}
-	void EndRead() { m_BlockFiles.clear(); }
-
-	RecordedRequestInfo ReadRequest(uint64_t RequestIndex, IoBuffer& OutBuffer) const
-	{
-		if (RequestIndex >= m_Entries.size())
-		{
-			return RecordedRequestInfo::NullRequest;
-		}
-
-		const RecordedRequest& Entry = m_Entries[RequestIndex];
-		if (Entry.Length == 0)
-		{
-			return RecordedRequestInfo::NullRequest;
-		}
-
-		if (Entry.Offset != ~0ull)
-		{
-			uint32_t BlockIndex	 = gsl::narrow<uint32_t>((Entry.Offset + Entry.Length) / RecordedRequestBlockSize);
-			uint64_t ChunkOffset = Entry.Offset - (BlockIndex * RecordedRequestBlockSize);
-			OutBuffer			 = IoBuffer(m_BlockFiles[BlockIndex], ChunkOffset, Entry.Length);
-		}
-		else
-		{
-			OutBuffer = IoBufferBuilder::MakeFromFile(m_BasePath / fmt::format("request{}.bin", RequestIndex));
-		}
-
-		return {.ContentType = Entry.ContentType, .AcceptType = Entry.AcceptType, .SessionId = Oid::Zero};
-	}
-
-	std::filesystem::path		 m_BasePath;
-	std::vector<RecordedRequest> m_Entries;
-	std::vector<IoBuffer>		 m_BlockFiles;
-};
-
-class DiskRequestRecorder : public IRpcRequestRecorder
-{
-public:
-	DiskRequestRecorder(const std::filesystem::path& BasePath) { m_RecordedRequests.BeginWrite(BasePath); }
-	virtual ~DiskRequestRecorder() { m_RecordedRequests.EndWrite(); }
-
-private:
-	virtual void RecordRequest(const RecordedRequestInfo& RequestInfo, const IoBuffer& RequestBuffer) override
-	{
-		m_RecordedRequests.WriteRequest(RequestInfo, RequestBuffer);
-	}
-
-	RecordedRequestsWriter m_RecordedRequests;
-};
-
-class DiskRequestReplayer : public IRpcRequestReplayer
-{
-public:
-	DiskRequestReplayer(const std::filesystem::path& BasePath, bool InMemory)
-	{
-		m_RequestCount = m_RequestBuffer.BeginRead(BasePath, InMemory);
-	}
-	virtual ~DiskRequestReplayer() { m_RequestBuffer.EndRead(); }
-
-	virtual uint64_t GetRequestCount() const override { return m_RequestCount; }
-
-	virtual RecordedRequestInfo GetRequest(uint64_t RequestIndex, IoBuffer& OutBuffer) override
-	{
-		return m_RequestBuffer.ReadRequest(RequestIndex, OutBuffer);
-	}
-
-private:
-	std::uint64_t		   m_RequestCount;
-	RecordedRequestsReader m_RequestBuffer;
-};
-
-}  // namespace zen::cache::v1
-
 //////////////////////////////////////////////////////////////////////////
 
 namespace zen::cache::v2 {
@@ -1184,7 +964,7 @@ MakeDiskRequestReplayer(const std::filesystem::path& BasePath, bool InMemory)
 	}
 	else
 	{
-		return std::make_unique<v1::DiskRequestReplayer>(BasePath, InMemory);
+		return nullptr;
 	}
 }