path: root/src/zenserver/sessions/sessions.cpp

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

#include "sessions.h"

#include <zencore/basicfile.h>
#include <zencore/fmtutils.h>
#include <zencore/logging.h>

namespace zen {
using namespace std::literals;

class SessionLog : public TRefCounted<SessionLog>
{
public:
	SessionLog(std::filesystem::path LogFilePath) { m_LogFile.Open(LogFilePath, BasicFile::Mode::kWrite); }

private:
	BasicFile m_LogFile;
};

class SessionLogStore
{
public:
	SessionLogStore(std::filesystem::path StoragePath) : m_StoragePath(std::move(StoragePath)) {}

	~SessionLogStore() = default;

	Ref<SessionLog> GetLogForSession(const Oid& SessionId)
	{
		// For now, just return a new log for each session. We can implement actual log storage and retrieval later.
		return Ref(new SessionLog(m_StoragePath / (SessionId.ToString() + ".log")));
	}

	Ref<SessionLog> CreateLogForSession(const Oid& SessionId)
	{
		// For now, just return a new log for each session. We can implement actual log storage and retrieval later.
		return Ref(new SessionLog(m_StoragePath / (SessionId.ToString() + ".log")));
	}

private:
	std::filesystem::path m_StoragePath;
};

SessionsService::Session::Session(const SessionInfo& Info) : m_Info(Info)
{
}
SessionsService::Session::~Session() = default;

void
SessionsService::Session::AppendLog(LogEntry Entry)
{
	RwLock::ExclusiveLockScope Lock(m_LogLock);
	m_LogEntries.push_back(std::move(Entry));
	++m_TotalAppended;
	while (m_LogEntries.size() > MaxLogEntries)
	{
		m_LogEntries.pop_front();
	}
}

std::vector<SessionsService::LogEntry>
SessionsService::Session::GetLogEntries(uint32_t Limit, uint32_t Offset) const
{
	RwLock::SharedLockScope Lock(m_LogLock);

	const uint32_t Total = uint32_t(m_LogEntries.size());
	if (Offset >= Total)
	{
		return {};
	}

	const uint32_t Available = Total - Offset;
	const uint32_t Count	 = (Limit > 0) ? std::min(Limit, Available) : Available;

	std::vector<LogEntry> Result;
	Result.reserve(Count);
	for (uint32_t i = Offset; i < Offset + Count; i++)
	{
		Result.push_back(m_LogEntries[i]);
	}
	return Result;
}

uint64_t
SessionsService::Session::GetLogCount() const
{
	RwLock::SharedLockScope Lock(m_LogLock);
	return m_LogEntries.size();
}

SessionsService::Session::CursorResult
SessionsService::Session::GetLogEntriesAfter(uint64_t AfterCursor) const
{
	RwLock::SharedLockScope Lock(m_LogLock);

	const uint64_t DequeSize = m_LogEntries.size();

	// Cursor 0 means "give me everything currently in the deque".
	// Otherwise, compute how many new entries were appended since the cursor.
	uint64_t NewCount = (AfterCursor == 0) ? DequeSize : (m_TotalAppended > AfterCursor ? m_TotalAppended - AfterCursor : 0);

	// Clamp to what's actually available in the deque (entries may have been evicted).
	NewCount = std::min(NewCount, DequeSize);

	std::vector<LogEntry> Result;
	Result.reserve(NewCount);

	const uint64_t StartIndex = DequeSize - NewCount;
	for (uint64_t i = StartIndex; i < DequeSize; i++)
	{
		Result.push_back(m_LogEntries[i]);
	}

	return CursorResult{
		.Entries = std::move(Result),
		.Cursor	 = m_TotalAppended,
		.Count	 = DequeSize,
	};
}

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

SessionsService::SessionsService() : m_Log(logging::Get("sessions"))
{
}

SessionsService::~SessionsService() = default;

bool
SessionsService::RegisterSession(const Oid& SessionId, std::string AppName, std::string Mode, const Oid& JobId, CbObjectView Metadata)
{
	// Log outside the lock scope — InProcSessionLogSink calls back into
	// GetSession() which acquires m_Lock shared, so logging while holding
	// m_Lock exclusively would deadlock.
	{
		RwLock::ExclusiveLockScope Lock(m_Lock);

		if (m_Sessions.contains(SessionId))
		{
			return false;
		}

		const DateTime Now = DateTime::Now();
		m_Sessions.emplace(SessionId,
						   Ref(new Session(SessionInfo{.Id		  = SessionId,
													   .AppName	  = AppName,
													   .Mode	  = Mode,
													   .JobId	  = JobId,
													   .Metadata  = CbObject::Clone(Metadata),
													   .CreatedAt = Now,
													   .UpdatedAt = Now})));
	}

	ZEN_INFO("Session {} registered (AppName: {}, Mode: {}, JobId: {})", SessionId, AppName, Mode, JobId);
	return true;
}

bool
SessionsService::UpdateSession(const Oid& SessionId, CbObjectView Metadata)
{
	RwLock::ExclusiveLockScope Lock(m_Lock);

	auto It = m_Sessions.find(SessionId);
	if (It == m_Sessions.end())
	{
		return false;
	}

	It.value()->UpdateMetadata(Metadata);

	const SessionInfo& Info = It.value()->Info();
	ZEN_DEBUG("Session {} updated (AppName: {}, JobId: {})", SessionId, Info.AppName, Info.JobId);
	return true;
}

Ref<SessionsService::Session>
SessionsService::GetSession(const Oid& SessionId) const
{
	RwLock::SharedLockScope Lock(m_Lock);

	auto It = m_Sessions.find(SessionId);
	if (It == m_Sessions.end())
	{
		return {};
	}

	return It->second;
}

std::vector<Ref<SessionsService::Session>>
SessionsService::GetSessions() const
{
	RwLock::SharedLockScope Lock(m_Lock);

	std::vector<Ref<Session>> Result;
	Result.reserve(m_Sessions.size());
	for (const auto& [Id, SessionRef] : m_Sessions)
	{
		Result.push_back(SessionRef);
	}
	return Result;
}

bool
SessionsService::RemoveSession(const Oid& SessionId)
{
	std::string RemovedAppName;
	Oid			RemovedJobId;

	{
		RwLock::ExclusiveLockScope Lock(m_Lock);

		auto It = m_Sessions.find(SessionId);
		if (It == m_Sessions.end())
		{
			return false;
		}

		RemovedAppName = It.value()->Info().AppName;
		RemovedJobId   = It.value()->Info().JobId;

		Ref<Session> Ended = It.value();
		Ended->SetEndedAt(DateTime::Now());
		m_EndedSessions.push_back(std::move(Ended));

		m_Sessions.erase(It);
	}

	ZEN_INFO("Session {} removed (AppName: {}, JobId: {})", SessionId, RemovedAppName, RemovedJobId);
	return true;
}

std::vector<Ref<SessionsService::Session>>
SessionsService::GetEndedSessions() const
{
	RwLock::SharedLockScope Lock(m_Lock);
	return m_EndedSessions;
}

uint64_t
SessionsService::GetSessionCount() const
{
	RwLock::SharedLockScope Lock(m_Lock);
	return m_Sessions.size();
}

}  // namespace zen