Skip to content

Implement libtorrent task persistence with SQLite and resume data support #4

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
Copilot wants to merge 3 commits into
base: dev_master
Choose a base branch
from
Draft

Implement libtorrent task persistence with SQLite and resume data support #4

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
b45210e
Initial plan
Copilot Nov 30, 2025
fe44d6c
Add TorrentStateManager for libtorrent session and task persistence w…
Copilot Nov 30, 2025
d34edec
Fix code review issues: race conditions and date formatting
Copilot Nov 30, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
82 changes: 82 additions & 0 deletions OpenNet/Core/P2PManager.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -27,9 +27,28 @@ namespace OpenNet::Core
co_await winrt::resume_background();
{
std::scoped_lock lk(m_torrentMutex);

// Initialize state manager first
if (!m_stateManager)
{
m_stateManager = std::make_unique<OpenNet::Core::Torrent::TorrentStateManager>();
if (!m_stateManager->Initialize())
{
OutputDebugStringA("Failed to initialize TorrentStateManager\n");
// Continue anyway, persistence will just be disabled
}
}

if (!m_torrentCore)
{
m_torrentCore = std::make_unique<OpenNet::Core::Torrent::LibtorrentHandle>();

// Set state manager before initialization
if (m_stateManager)
{
m_torrentCore->SetStateManager(m_stateManager.get());
}

if (!m_torrentCore->Initialize())
{
m_torrentCore.reset();
Expand All @@ -42,6 +61,9 @@ namespace OpenNet::Core
}
m_isTorrentCoreInitialized.store(true);
m_initializing.store(false);

// Load and resume saved tasks
co_await LoadAndResumeSavedTasksAsync();
}

IAsyncOperation<bool> P2PManager::AddMagnetAsync(std::string magnetUri, std::string savePath)
Expand All @@ -52,6 +74,66 @@ namespace OpenNet::Core
co_return m_torrentCore->AddMagnet(magnetUri, savePath);
}

IAsyncAction P2PManager::LoadAndResumeSavedTasksAsync()
{
co_await winrt::resume_background();

std::scoped_lock lk(m_torrentMutex);
if (!m_stateManager || !m_torrentCore) co_return;

auto tasks = m_stateManager->LoadAllTasks();
for (auto const& task : tasks)
{
// Only resume non-completed, non-failed tasks
if (task.status == 1 || task.status == 2) // Downloading or Paused
{
std::string resumedId = m_torrentCore->AddTorrentFromResumeData(task.taskId);
if (!resumedId.empty())
{
OutputDebugStringA(("Resumed task: " + task.taskId + "\n").c_str());
}
}
}
}

std::vector<::OpenNet::Core::Torrent::TaskMetadata> P2PManager::GetAllTasks()
{
std::scoped_lock lk(m_torrentMutex);
if (!m_stateManager) return {};
return m_stateManager->LoadAllTasks();
}

IAsyncOperation<bool> P2PManager::ExportTasksAsync(std::wstring filePath)
{
co_await winrt::resume_background();
std::scoped_lock lk(m_torrentMutex);
if (!m_stateManager) co_return false;
co_return m_stateManager->ExportToFile(filePath);
}

IAsyncOperation<bool> P2PManager::ImportTasksAsync(std::wstring filePath)
{
co_await winrt::resume_background();
std::scoped_lock lk(m_torrentMutex);
if (!m_stateManager) co_return false;
bool result = m_stateManager->ImportFromFile(filePath);

// Resume imported tasks
if (result && m_torrentCore)
{
auto tasks = m_stateManager->LoadAllTasks();
for (auto const& task : tasks)
{
if (task.status == 1 || task.status == 2)
{
m_torrentCore->AddTorrentFromResumeData(task.taskId);
}
}
}

co_return result;
}

void P2PManager::SetProgressCallback(ProgressCb cb)
{
std::scoped_lock lk(m_cbMutex);
Expand Down
19 changes: 19 additions & 0 deletions OpenNet/Core/P2PManager.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,9 +6,11 @@
#include <atomic>
#include <functional>
#include <string>
#include <vector>

// Include torrent core so nested ProgressEvent is known
#include "Core/torrentCore/libtorrentHandle.h"
#include "Core/torrentCore/TorrentStateManager.h"

namespace OpenNet::Core
{
Expand All @@ -35,9 +37,25 @@ namespace OpenNet::Core
return m_torrentCore.get();
}

// State manager access
::OpenNet::Core::Torrent::TorrentStateManager* StateManager() noexcept
{
return m_stateManager.get();
}

// Torrent operations
winrt::Windows::Foundation::IAsyncOperation<bool> AddMagnetAsync(std::string magnetUri, std::string savePath);

// Load all saved tasks and resume them
winrt::Windows::Foundation::IAsyncAction LoadAndResumeSavedTasksAsync();

// Get all saved task metadata
std::vector<::OpenNet::Core::Torrent::TaskMetadata> GetAllTasks();

// Import/Export task data
winrt::Windows::Foundation::IAsyncOperation<bool> ExportTasksAsync(std::wstring filePath);
winrt::Windows::Foundation::IAsyncOperation<bool> ImportTasksAsync(std::wstring filePath);

// Callback registration
using ProgressCb = std::function<void(const ::OpenNet::Core::Torrent::LibtorrentHandle::ProgressEvent&)>;
using FinishedCb = std::function<void(const std::string&)>;
Expand All @@ -54,6 +72,7 @@ namespace OpenNet::Core
void WireCoreCallbacks();

std::unique_ptr<::OpenNet::Core::Torrent::LibtorrentHandle> m_torrentCore;
std::unique_ptr<::OpenNet::Core::Torrent::TorrentStateManager> m_stateManager;
std::mutex m_torrentMutex;
std::atomic<bool> m_isTorrentCoreInitialized{ false };
std::atomic<bool> m_initializing{ false };
Expand Down
Loading