path: root/src/zenserver/projectstore/projectstore.h

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

#pragma once

#include <zencore/compactbinarybuilder.h>
#include <zencore/compositebuffer.h>
#include <zencore/uid.h>
#include <zencore/xxhash.h>
#include <zenhttp/httpserver.h>
#include <zenstore/gc.h>

ZEN_THIRD_PARTY_INCLUDES_START
#include <tsl/robin_map.h>
ZEN_THIRD_PARTY_INCLUDES_END

#include <map>
#include <unordered_map>

namespace zen {

class CbPackage;
class CidStore;
class AuthMgr;
class ScrubContext;
class JobQueue;
class OpenProcessCache;

/** Project Store

	A project store consists of a number of Projects.

	Each project contains a number of oplogs (short for "operation log"). UE uses
	one oplog per target platform to store the output of the cook process.

	An oplog consists of a sequence of "op" entries. Each entry is a structured object
	containing references to attachments. Attachments are typically the serialized
	package data split into separate chunks for bulk data, exports and header
	information.
 */
class ProjectStore : public RefCounted, public GcStorage, public GcReferencer, public GcReferenceLocker
{
	struct OplogStorage;

public:
	struct Configuration
	{
	};

	ProjectStore(CidStore&			   Store,
				 std::filesystem::path BasePath,
				 GcManager&			   Gc,
				 JobQueue&			   JobQueue,
				 OpenProcessCache&	   InOpenProcessCache,
				 const Configuration&  Config);
	~ProjectStore();

	struct LogSequenceNumber
	{
		uint32_t Number = 0u;

		operator bool() const { return Number != 0u; };
		LogSequenceNumber() = default;
		explicit LogSequenceNumber(size_t InNumber) : Number(uint32_t(InNumber)) {}
					operator size_t() const { return Number; };
		inline auto operator<=>(const LogSequenceNumber& Other) const = default;

		struct Hasher
		{
			size_t operator()(const LogSequenceNumber& v) const { return std::hash<uint32_t>()(v.Number); }
		};
	};

	template<class V>
	using LsnMap = tsl::robin_map<LogSequenceNumber, V, LogSequenceNumber::Hasher>;

	struct OplogEntryAddress
	{
		uint32_t Offset;  // note: Multiple of m_OpsAlign!
		uint32_t Size;
	};

	struct OplogEntry
	{
		LogSequenceNumber OpLsn;
		OplogEntryAddress OpCoreAddress;
		uint32_t		  OpCoreHash;  // Used as checksum
		Oid				  OpKeyHash;
		uint32_t		  Reserved;

		inline bool IsTombstone() const { return OpCoreAddress.Offset == 0 && OpCoreAddress.Size == 0 && OpLsn.Number; }
		inline void MakeTombstone()
		{
			OpLsn				 = {};
			OpCoreAddress.Offset = OpCoreAddress.Size = OpCoreHash = Reserved = 0;
		}
	};

	static_assert(IsPow2(sizeof(OplogEntry)));

	struct Oplog : public RefCounted
	{
		enum class EMode
		{
			kBasicReadOnly,
			kFull
		};

		Oplog(const LoggerRef&			   Log,
			  std::string_view			   ProjectIdentifier,
			  std::string_view			   Id,
			  CidStore&					   Store,
			  const std::filesystem::path& BasePath,
			  const std::filesystem::path& MarkerPath,
			  EMode						   State);
		~Oplog();

		[[nodiscard]] static bool ExistsAt(const std::filesystem::path& BasePath);
		bool					  Exists() const;

		void Read();
		void Write();
		void Update(const std::filesystem::path& MarkerPath);
		bool Reset();
		bool CanUnload();

		struct ChunkInfo
		{
			Oid		 ChunkId;
			uint64_t ChunkSize;
		};

		struct Paging
		{
			int32_t Start = -1;
			int32_t Count = -1;
		};

		std::vector<ChunkInfo> GetAllChunksInfo(const std::filesystem::path& ProjectRootDir);
		void				   IterateChunkMap(std::function<void(const Oid&, const IoHash& Hash)>&& Fn);
		void   IterateFileMap(std::function<void(const Oid&, const std::string_view& ServerPath, const std::string_view& ClientPath)>&& Fn);
		void   IterateOplog(std::function<void(CbObjectView)>&& Fn, const Paging& EntryPaging);
		void   IterateOplogWithKey(std::function<void(LogSequenceNumber, const Oid&, CbObjectView)>&& Fn);
		void   IterateOplogWithKey(std::function<void(LogSequenceNumber, const Oid&, CbObjectView)>&& Fn, const Paging& EntryPaging);
		void   IterateOplogLocked(std::function<void(CbObjectView)>&& Fn, const Paging& EntryPaging);
		size_t GetOplogEntryCount() const;

		std::optional<CbObject> GetOpByKey(const Oid& Key);
		std::optional<CbObject> GetOpByIndex(LogSequenceNumber Index);
		LogSequenceNumber		GetOpIndexByKey(const Oid& Key);

		IoBuffer FindChunk(const std::filesystem::path& ProjectRootDir, const Oid& ChunkId, uint64_t* OptOutModificationTag);
		IoBuffer GetChunkByRawHash(const IoHash& RawHash);
		bool	 IterateChunks(std::span<IoHash>																  RawHashes,
							   bool																				  IncludeModTag,
							   const std::function<bool(size_t Index, const IoBuffer& Payload, uint64_t ModTag)>& AsyncCallback,
							   WorkerThreadPool*																  OptionalWorkerPool,
							   uint64_t																			  LargeSizeLimit);
		bool	 IterateChunks(const std::filesystem::path&														  ProjectRootDir,
							   std::span<Oid>																	  ChunkIds,
							   bool																				  IncludeModTag,
							   const std::function<bool(size_t Index, const IoBuffer& Payload, uint64_t ModTag)>& AsyncCallback,
							   WorkerThreadPool*																  OptionalWorkerPool,
							   uint64_t																			  LargeSizeLimit);

		/** Persist a new oplog entry
		 *
		 * Returns the oplog LSN assigned to the new entry, or an invalid number if the entry is rejected
		 */
		LogSequenceNumber			   AppendNewOplogEntry(CbPackage Op);
		LogSequenceNumber			   AppendNewOplogEntry(CbObjectView Core);
		std::vector<LogSequenceNumber> AppendNewOplogEntries(std::span<CbObjectView> Cores);

		const std::string& OplogId() const { return m_OplogId; }

		const std::filesystem::path& TempPath() const { return m_TempPath; }
		const std::filesystem::path& MarkerPath() const { return m_MarkerPath; }

		LoggerRef		Log() const { return m_Log; }
		void			Flush();
		void			Scrub(ScrubContext& Ctx);
		static uint64_t TotalSize(const std::filesystem::path& BasePath);
		uint64_t		TotalSize() const;

		std::size_t OplogCount() const
		{
			RwLock::SharedLockScope _(m_OplogLock);
			return m_OpToPayloadOffsetMap.size();
		}

		void ResetState();
		bool PrepareForDelete(std::filesystem::path& OutRemoveDirectory);

		void				EnableUpdateCapture();
		void				DisableUpdateCapture();
		void				CaptureAddedAttachments(std::span<const IoHash> AttachmentHashes);
		std::vector<IoHash> GetCapturedAttachmentsLocked();
		std::vector<IoHash> CheckPendingChunkReferences(std::span<const IoHash> ChunkHashes, const GcClock::Duration& RetainTime);
		void				RemovePendingChunkReferences(std::span<const IoHash> ChunkHashes);
		std::vector<IoHash> GetPendingChunkReferencesLocked();

		RwLock::SharedLockScope GetGcReferencerLock() { return RwLock::SharedLockScope(m_OplogLock); }

		uint32_t GetUnusedSpacePercent() const;
		void	 Compact(bool DryRun, bool RetainLSNs, std::string_view LogPrefix);

		void GetAttachmentsLocked(std::vector<IoHash>& OutAttachments, bool StoreMetaDataOnDisk);

		std::string_view GetOuterProjectIdentifier() const { return m_OuterProjectId; }
		void			 CompactIfUnusedExceeds(bool DryRun, uint32_t CompactUnusedThreshold, std::string_view LogPrefix);

		static std::optional<CbObject> ReadStateFile(const std::filesystem::path& BasePath, std::function<LoggerRef()>&& Log);

		struct ChunkMapping
		{
			Oid	   Id;
			IoHash Hash;
		};

		struct FileMapping
		{
			Oid			Id;
			IoHash		Hash;		 // This is either zero or a cid
			std::string ServerPath;	 // If Hash is valid then this should be empty
			std::string ClientPath;
		};

		struct ValidationResult
		{
			uint32_t								  OpCount = 0;
			LogSequenceNumber						  LSNLow;
			LogSequenceNumber						  LSNHigh;
			std::vector<std::pair<Oid, FileMapping>>  MissingFiles;
			std::vector<std::pair<Oid, ChunkMapping>> MissingChunks;
			std::vector<std::pair<Oid, ChunkMapping>> MissingMetas;
			std::vector<std::pair<Oid, IoHash>>		  MissingAttachments;
			std::vector<std::pair<Oid, std::string>>  OpKeys;

			bool IsEmpty() const
			{
				return MissingFiles.empty() && MissingChunks.empty() && MissingMetas.empty() && MissingAttachments.empty();
			}
		};

		ValidationResult Validate(const std::filesystem::path& ProjectRootDir,
								  std::atomic_bool&			   IsCancelledFlag,
								  WorkerThreadPool*			   OptionalWorkerPool);

	private:
		struct FileMapEntry
		{
			std::string ServerPath;
			std::string ClientPath;
		};

		template<class V>
		using OidMap = tsl::robin_map<Oid, V, Oid::Hasher>;

		LoggerRef					m_Log;
		const std::string			m_OuterProjectId;
		const std::string			m_OplogId;
		CidStore&					m_CidStore;
		const std::filesystem::path m_BasePath;
		std::filesystem::path		m_MarkerPath;
		const std::filesystem::path m_TempPath;
		const std::filesystem::path m_MetaPath;

		const EMode m_Mode;

		mutable RwLock		 m_OplogLock;
		OidMap<IoHash>		 m_ChunkMap;		 // output data chunk id -> CAS address
		OidMap<IoHash>		 m_MetaMap;			 // meta chunk id -> CAS address
		OidMap<FileMapEntry> m_FileMap;			 // file id -> file map entry
		int32_t				 m_ManifestVersion;	 // File system manifest version

		struct PayloadIndex
		{
			uint32_t Index = std::numeric_limits<uint32_t>::max();

			operator bool() const { return Index != std::numeric_limits<uint32_t>::max(); };
			PayloadIndex() = default;
			explicit PayloadIndex(size_t InIndex) : Index(uint32_t(InIndex)) {}
						operator size_t() const { return Index; };
			inline auto operator<=>(const PayloadIndex& Other) const = default;

			struct Hasher
			{
				size_t operator()(const PayloadIndex& v) const { return std::hash<uint32_t>()(v.Index); }
			};
		};

		struct OplogPayload
		{
			LogSequenceNumber Lsn;
			OplogEntryAddress Address;
		};

		OidMap<PayloadIndex>				  m_OpToPayloadOffsetMap;
		std::vector<OplogPayload>			  m_OpLogPayloads;
		std::unique_ptr<LsnMap<PayloadIndex>> m_LsnToPayloadOffsetMap;

		std::atomic<bool> m_MetaValid = false;

		uint32_t								   m_UpdateCaptureRefCounter = 0;
		std::unique_ptr<std::vector<Oid>>		   m_CapturedOps;
		std::unique_ptr<std::vector<IoHash>>	   m_CapturedAttachments;
		std::unordered_set<IoHash, IoHash::Hasher> m_PendingPrepOpAttachments;
		GcClock::TimePoint						   m_PendingPrepOpAttachmentsRetainEnd;

		RefPtr<OplogStorage> m_Storage;
		uint64_t			 m_LogFlushPosition = 0;
		bool				 m_IsLegacySnapshot = false;

		RefPtr<OplogStorage> GetStorage();

		/** Scan oplog and register each entry, thus updating the in-memory tracking tables
		 */
		uint32_t GetUnusedSpacePercentLocked() const;
		void	 WriteIndexSnapshot();
		void	 ReadIndexSnapshot();
		void	 RefreshLsnToPayloadOffsetMap(RwLock::ExclusiveLockScope&);

		struct OplogEntryMapping
		{
			std::vector<ChunkMapping> Chunks;
			std::vector<ChunkMapping> Meta;
			std::vector<FileMapping>  Files;
		};

		OplogEntryMapping GetMapping(CbObjectView Core);

		/** Update tracking metadata for a new oplog entry
		 *
		 * This is used during replay (and gets called as part of new op append)
		 *
		 * Returns the oplog LSN assigned to the new entry, or kInvalidOp if the entry is rejected
		 */
		LogSequenceNumber RegisterOplogEntry(RwLock::ExclusiveLockScope& OplogLock,
											 const OplogEntryMapping&	 OpMapping,
											 const OplogEntry&			 OpEntry);

		void AddFileMapping(const RwLock::ExclusiveLockScope& OplogLock,
							const Oid&						  FileId,
							const IoHash&					  Hash,
							std::string_view				  ServerPath,
							std::string_view				  ClientPath);
		void AddChunkMapping(const RwLock::ExclusiveLockScope& OplogLock, const Oid& ChunkId, const IoHash& Hash);
		void AddMetaMapping(const RwLock::ExclusiveLockScope& OplogLock, const Oid& ChunkId, const IoHash& Hash);
		void Compact(RwLock::ExclusiveLockScope& Lock, bool DryRun, bool RetainLSNs, std::string_view LogPrefix);
		void IterateCapturedOpsLocked(std::function<bool(const Oid& Key, LogSequenceNumber LSN, const CbObjectView& UpdateOp)>&& Callback);
		std::vector<PayloadIndex> GetSortedOpPayloadRangeLocked(
			const Paging&											 EntryPaging,
			tsl::robin_map<PayloadIndex, Oid, PayloadIndex::Hasher>* OutOptionalReverseKeyMap);

		friend class ProjectStoreOplogReferenceChecker;
		friend class ProjectStoreReferenceChecker;
		friend class ProjectStoreOplogReferenceValidator;
		friend struct OplogStorage;
	};

	struct Project : public RefCounted
	{
		std::string			  Identifier;
		std::filesystem::path RootDir;
		std::filesystem::path EngineRootDir;
		std::filesystem::path ProjectRootDir;
		std::filesystem::path ProjectFilePath;

		Ref<Oplog>				 NewOplog(std::string_view OplogId, const std::filesystem::path& MarkerPath);
		Ref<Oplog>				 OpenOplog(std::string_view OplogId, bool AllowCompact, bool VerifyPathOnDisk);
		Ref<Oplog>				 ReadOplog(std::string_view OplogId);
		bool					 TryUnloadOplog(std::string_view OplogId);
		bool					 DeleteOplog(std::string_view OplogId);
		bool					 RemoveOplog(std::string_view OplogId, std::filesystem::path& OutDeletePath);
		void					 IterateOplogs(std::function<void(const RwLock::SharedLockScope&, const Oplog&)>&& Fn) const;
		void					 IterateOplogs(std::function<void(const RwLock::SharedLockScope&, Oplog&)>&& Fn);
		std::vector<std::string> ScanForOplogs() const;
		bool					 IsExpired(const GcClock::TimePoint ExpireTime) const;
		bool					 IsExpired(const GcClock::TimePoint ExpireTime, const ProjectStore::Oplog& Oplog) const;
		bool					 IsExpired(const GcClock::TimePoint ExpireTime, std::string_view OplogId) const;
		bool					 IsOplogTouchedSince(const GcClock::TimePoint TouchTime, std::string_view Oplog) const;
		void					 TouchProject();
		void					 TouchOplog(std::string_view Oplog);
		GcClock::TimePoint		 LastOplogAccessTime(std::string_view Oplog) const;

		Project(ProjectStore* PrjStore, CidStore& Store, std::filesystem::path BasePath);
		virtual ~Project();

		void					  Read();
		void					  Write();
		[[nodiscard]] static bool Exists(const std::filesystem::path& BasePath);
		void					  Flush();
		void					  Scrub(ScrubContext& Ctx);
		LoggerRef				  Log() const;
		static uint64_t			  TotalSize(const std::filesystem::path& BasePath);
		uint64_t				  TotalSize() const;
		bool					  PrepareForDelete(std::filesystem::path& OutDeletePath);

		void					 EnableUpdateCapture();
		void					 DisableUpdateCapture();
		std::vector<std::string> GetCapturedOplogsLocked();

		std::vector<RwLock::SharedLockScope> GetGcReferencerLocks();

		void AddOplogToCompact(std::string_view OplogId)
		{
			m_OplogsToCompactLock.WithExclusiveLock([&]() { m_OplogsToCompact.insert(std::string(OplogId)); });
		}
		std::vector<std::string> GetOplogsToCompact()
		{
			std::vector<std::string> Result;
			m_OplogsToCompactLock.WithExclusiveLock([&]() {
				Result.reserve(m_OplogsToCompact.size());
				Result.insert(Result.end(), m_OplogsToCompact.begin(), m_OplogsToCompact.end());
				m_OplogsToCompact.clear();
			});
			return Result;
		}

	private:
		ProjectStore*									   m_ProjectStore;
		CidStore&										   m_CidStore;
		mutable RwLock									   m_ProjectLock;
		std::map<std::string, Ref<Oplog>>				   m_Oplogs;
		std::filesystem::path							   m_OplogStoragePath;
		mutable RwLock									   m_LastAccessTimesLock;
		mutable tsl::robin_map<std::string, GcClock::Tick> m_LastAccessTimes;
		uint32_t										   m_UpdateCaptureRefCounter = 0;
		std::unique_ptr<std::vector<std::string>>		   m_CapturedOplogs;

		RwLock							m_OplogsToCompactLock;
		std::unordered_set<std::string> m_OplogsToCompact;

		std::filesystem::path BasePathForOplog(std::string_view OplogId) const;
		bool IsExpired(const std::string& EntryName, const std::filesystem::path& MarkerPath, const GcClock::TimePoint ExpireTime) const;
		void WriteAccessTimes();
		void ReadAccessTimes();

		friend class ProjectStoreOplogReferenceChecker;
		friend class ProjectStoreReferenceChecker;
		friend class ProjectStoreOplogReferenceValidator;
		friend class ProjectStoreGcStoreCompactor;
	};

	Ref<Project> OpenProject(std::string_view ProjectId);
	Ref<Project> NewProject(const std::filesystem::path& BasePath,
							std::string_view			 ProjectId,
							const std::filesystem::path& RootDir,
							const std::filesystem::path& EngineRootDir,
							const std::filesystem::path& ProjectRootDir,
							const std::filesystem::path& ProjectFilePath);
	bool		 UpdateProject(std::string_view				ProjectId,
							   const std::filesystem::path& RootDir,
							   const std::filesystem::path& EngineRootDir,
							   const std::filesystem::path& ProjectRootDir,
							   const std::filesystem::path& ProjectFilePath);
	bool		 RemoveProject(std::string_view ProjectId, std::filesystem::path& OutDeletePath);
	bool		 DeleteProject(std::string_view ProjectId);
	bool		 Exists(std::string_view ProjectId);
	void		 Flush();
	void		 DiscoverProjects();
	void		 IterateProjects(std::function<void(Project& Prj)>&& Fn);

	LoggerRef					 Log() { return m_Log; }
	const std::filesystem::path& BasePath() const { return m_ProjectBasePath; }

	// GcStorage
	virtual void		  ScrubStorage(ScrubContext& Ctx) override;
	virtual GcStorageSize StorageSize() const override;

	virtual std::string						   GetGcName(GcCtx& Ctx) override;
	virtual GcStoreCompactor*				   RemoveExpiredData(GcCtx& Ctx, GcStats& Stats) override;
	virtual std::vector<GcReferenceChecker*>   CreateReferenceCheckers(GcCtx& Ctx) override;
	virtual std::vector<GcReferenceValidator*> CreateReferenceValidators(GcCtx& Ctx) override;

	virtual std::vector<RwLock::SharedLockScope> LockState(GcCtx& Ctx) override;

	CbArray			GetProjectsList();
	static CbObject GetProjectFiles(LoggerRef							   InLog,
									Project&							   Project,
									Oplog&								   Oplog,
									const std::unordered_set<std::string>& WantedFieldNames);

	static CbObject GetProjectChunkInfos(LoggerRef								InLog,
										 Project&								Project,
										 Oplog&									Oplog,
										 const std::unordered_set<std::string>& WantedFieldNames);
	static CbObject GetChunkInfo(LoggerRef InLog, Project& Project, Oplog& Oplog, const Oid& ChunkId);
	struct GetChunkRangeResult
	{
		enum class EError : uint8_t
		{
			Ok,
			NotFound,
			NotModified,
			MalformedContent,
			OutOfRange
		};
		EError			Error = EError(-1);
		std::string		ErrorDescription;
		CompositeBuffer Chunk		= CompositeBuffer();
		IoHash			RawHash		= IoHash::Zero;
		uint64_t		RawSize		= 0;
		ZenContentType	ContentType = ZenContentType::kUnknownContentType;
	};
	static GetChunkRangeResult GetChunkRange(LoggerRef		InLog,
											 Project&		Project,
											 Oplog&			Oplog,
											 const Oid&		ChunkId,
											 uint64_t		Offset,
											 uint64_t		Size,
											 ZenContentType AcceptType,
											 uint64_t*		OptionalInOutModificationTag);
	IoBuffer				   GetChunk(Project& Project, Oplog& Oplog, const IoHash& ChunkHash);

	IoBuffer GetChunk(const std::string_view ProjectId, const std::string_view OplogId, const Oid& ChunkId);

	IoBuffer GetChunk(const std::string_view ProjectId, const std::string_view OplogId, const IoHash& Cid);

	bool PutChunk(Project& Project, Oplog& Oplog, const IoHash& ChunkHash, IoBuffer&& Chunk);

	struct WriteOplogResult
	{
		int32_t				ErrorCode = 0;
		std::string			ErrorDescription;
		std::vector<IoHash> Need;
	};
	WriteOplogResult WriteOplog(Project& Project, Oplog& Oplog, const CbObject& ContainerObject);

	struct ReadOplogResult
	{
		int32_t		ErrorCode = 0;
		std::string ErrorDescription;
		CbObject	ContainerObject;
	};
	ReadOplogResult ReadOplog(Project& Project,
							  Oplog&   Oplog,
							  size_t   MaxBlockSize,
							  size_t   MaxChunkEmbedSize,
							  size_t   MaxChunksPerBlock,
							  size_t   ChunkFileSizeLimit);

	std::pair<HttpResponseCode, std::string> GetChunks(const std::string_view ProjectId,
													   const std::string_view OplogId,
													   const CbObject&		  RequestObject,
													   CbPackage&			  OutResponsePackage);

	bool Rpc(HttpServerRequest&		HttpReq,
			 const std::string_view ProjectId,
			 const std::string_view OplogId,
			 IoBuffer&&				Payload,
			 AuthMgr&				AuthManager);

	std::pair<HttpResponseCode, std::string> Export(Ref<Project> Project, Oplog& Oplog, CbObjectView&& Params, AuthMgr& AuthManager);

	std::pair<HttpResponseCode, std::string> Import(Project& Project, Oplog& Oplog, CbObjectView&& Params, AuthMgr& AuthManager);

	bool AreDiskWritesAllowed() const;

	void					 EnableUpdateCapture();
	void					 DisableUpdateCapture();
	std::vector<std::string> GetCapturedProjectsLocked();

private:
	LoggerRef								  m_Log;
	GcManager&								  m_Gc;
	CidStore&								  m_CidStore;
	JobQueue&								  m_JobQueue;
	OpenProcessCache&						  m_OpenProcessCache;
	std::filesystem::path					  m_ProjectBasePath;
	const Configuration						  m_Config;
	mutable RwLock							  m_ProjectsLock;
	std::map<std::string, Ref<Project>>		  m_Projects;
	const DiskWriteBlocker*					  m_DiskWriteBlocker		= nullptr;
	uint32_t								  m_UpdateCaptureRefCounter = 0;
	std::unique_ptr<std::vector<std::string>> m_CapturedProjects;

	std::filesystem::path BasePathForProject(std::string_view ProjectId);

	friend class ProjectStoreGcStoreCompactor;
	friend class ProjectStoreOplogReferenceChecker;
	friend class ProjectStoreReferenceChecker;
};

Oid ComputeOpKey(const CbObjectView& Op);

Oid OpKeyStringAsOid(std::string_view OpKey);

template<typename T>
Oid
OpKeyStringAsOid(std::string_view OpKey, T& TmpBuffer)
{
	using namespace std::literals;

	CbObjectWriter Writer;
	Writer << "key"sv << OpKey;
	Writer.Finalize();
	TmpBuffer.resize(Writer.GetSaveSize());
	MutableMemoryView SaveBuffer(MutableMemoryView(TmpBuffer.data(), TmpBuffer.size()));

	const Oid OpId = ComputeOpKey(Writer.Save(SaveBuffer).AsObjectView());

	return OpId;
}

void prj_forcelink();

}  // namespace zen