#include <dbresumedatastorage.h>

Inheritance diagram for BitTorrent::DBResumeDataStorage:

Collaboration diagram for BitTorrent::DBResumeDataStorage:

[legend]

Classes
class	Worker

Public Member Functions
	DBResumeDataStorage (const QString &dbPath, QObject *parent=nullptr)

	~DBResumeDataStorage () override

QVector< TorrentID >	registeredTorrents () const override

std::optional< LoadTorrentParams >	load (const TorrentID &id) const override

void	store (const TorrentID &id, const LoadTorrentParams &resumeData) const override

void	remove (const TorrentID &id) const override

void	storeQueue (const QVector< TorrentID > &queue) const override

Private Member Functions
int	currentDBVersion () const

void	createDB () const

void	updateDBFromVersion1 () const

Private Attributes
QThread *	m_ioThread = nullptr

Worker *	m_asyncWorker = nullptr

Detailed Description

Definition at line 37 of file dbresumedatastorage.h.

Constructor & Destructor Documentation

◆ DBResumeDataStorage()

BitTorrent::DBResumeDataStorage::DBResumeDataStorage	(	const QString &	dbPath,
		QObject *	parent = `nullptr`
	)

explicit

Definition at line 191 of file dbresumedatastorage.cpp.

     : ResumeDataStorage {parent}
     , m_ioThread {new QThread(this)}
 {
     const bool needCreateDB = !QFile::exists(dbPath);
  
     auto db = QSqlDatabase::addDatabase(QLatin1String("QSQLITE"), DB_CONNECTION_NAME);
     db.setDatabaseName(dbPath);
     if (!db.open())
         throw RuntimeError(db.lastError().text());
  
     if (needCreateDB)
     {
         createDB();
     }
     else
     {
         const int dbVersion = currentDBVersion();
         if (dbVersion == 1)
             updateDBFromVersion1();
     }
  
     m_asyncWorker = new Worker(dbPath, QLatin1String("ResumeDataStorageWorker"));
     m_asyncWorker->moveToThread(m_ioThread);
     connect(m_ioThread, &QThread::finished, m_asyncWorker, &QObject::deleteLater);
     m_ioThread->start();
  
     RuntimeError *errPtr = nullptr;
     QMetaObject::invokeMethod(m_asyncWorker, [this, &errPtr]()
     {
         try
         {
             m_asyncWorker->openDatabase();
         }
         catch (const RuntimeError &err)
         {
             errPtr = new RuntimeError(err);
         }
     }, Qt::BlockingQueuedConnection);
  
     if (errPtr)
         throw *errPtr;
 }

References createDB(), currentDBVersion(), anonymous_namespace{dbresumedatastorage.cpp}::DB_CONNECTION_NAME, m_asyncWorker, m_ioThread, BitTorrent::DBResumeDataStorage::Worker::openDatabase(), and updateDBFromVersion1().

Here is the call graph for this function:

◆ ~DBResumeDataStorage()

BitTorrent::DBResumeDataStorage::~DBResumeDataStorage ( )

override

Definition at line 235 of file dbresumedatastorage.cpp.

 {
     QMetaObject::invokeMethod(m_asyncWorker, &Worker::closeDatabase);
     QSqlDatabase::removeDatabase(DB_CONNECTION_NAME);
  
     m_ioThread->quit();
     m_ioThread->wait();
 }

References anonymous_namespace{dbresumedatastorage.cpp}::DB_CONNECTION_NAME.

Member Function Documentation

◆ createDB()

void BitTorrent::DBResumeDataStorage::createDB ( ) const

private

Definition at line 390 of file dbresumedatastorage.cpp.

 {
     auto db = QSqlDatabase::database(DB_CONNECTION_NAME);
  
     if (!db.transaction())
         throw RuntimeError(db.lastError().text());
  
     QSqlQuery query {db};
  
     try
     {
         const QStringList tableMetaItems = {
             makeColumnDefinition(DB_COLUMN_ID, "INTEGER PRIMARY KEY"),
             makeColumnDefinition(DB_COLUMN_NAME, "TEXT NOT NULL UNIQUE"),
             makeColumnDefinition(DB_COLUMN_VALUE, "BLOB")
         };
         const QString createTableMetaQuery = makeCreateTableStatement(DB_TABLE_META, tableMetaItems);
         if (!query.exec(createTableMetaQuery))
             throw RuntimeError(query.lastError().text());
  
         const QString insertMetaVersionQuery = makeInsertStatement(DB_TABLE_META, {DB_COLUMN_NAME, DB_COLUMN_VALUE});
         if (!query.prepare(insertMetaVersionQuery))
             throw RuntimeError(query.lastError().text());
  
         query.bindValue(DB_COLUMN_NAME.placeholder, QString::fromLatin1(META_VERSION));
         query.bindValue(DB_COLUMN_VALUE.placeholder, DB_VERSION);
  
         if (!query.exec())
             throw RuntimeError(query.lastError().text());
  
         const QStringList tableTorrentsItems = {
             makeColumnDefinition(DB_COLUMN_ID, "INTEGER PRIMARY KEY"),
             makeColumnDefinition(DB_COLUMN_TORRENT_ID, "BLOB NOT NULL UNIQUE"),
             makeColumnDefinition(DB_COLUMN_QUEUE_POSITION, "INTEGER NOT NULL DEFAULT -1"),
             makeColumnDefinition(DB_COLUMN_NAME, "TEXT"),
             makeColumnDefinition(DB_COLUMN_CATEGORY, "TEXT"),
             makeColumnDefinition(DB_COLUMN_TAGS, "TEXT"),
             makeColumnDefinition(DB_COLUMN_TARGET_SAVE_PATH, "TEXT"),
             makeColumnDefinition(DB_COLUMN_CONTENT_LAYOUT, "TEXT NOT NULL"),
             makeColumnDefinition(DB_COLUMN_RATIO_LIMIT, "INTEGER NOT NULL"),
             makeColumnDefinition(DB_COLUMN_SEEDING_TIME_LIMIT, "INTEGER NOT NULL"),
             makeColumnDefinition(DB_COLUMN_HAS_OUTER_PIECES_PRIORITY, "INTEGER NOT NULL"),
             makeColumnDefinition(DB_COLUMN_HAS_SEED_STATUS, "INTEGER NOT NULL"),
             makeColumnDefinition(DB_COLUMN_OPERATING_MODE, "TEXT NOT NULL"),
             makeColumnDefinition(DB_COLUMN_STOPPED, "INTEGER NOT NULL"),
             makeColumnDefinition(DB_COLUMN_RESUMEDATA, "BLOB NOT NULL"),
             makeColumnDefinition(DB_COLUMN_METADATA, "BLOB")
         };
         const QString createTableTorrentsQuery = makeCreateTableStatement(DB_TABLE_TORRENTS, tableTorrentsItems);
         if (!query.exec(createTableTorrentsQuery))
             throw RuntimeError(query.lastError().text());
  
         if (!db.commit())
             throw RuntimeError(db.lastError().text());
     }
     catch (const RuntimeError &)
     {
         db.rollback();
         throw;
     }
 }

Referenced by DBResumeDataStorage().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ currentDBVersion()

int BitTorrent::DBResumeDataStorage::currentDBVersion ( ) const

private

Definition at line 363 of file dbresumedatastorage.cpp.

 {
     const auto selectDBVersionStatement = QString::fromLatin1("SELECT %1 FROM %2 WHERE %3 = %4;")
             .arg(quoted(DB_COLUMN_VALUE.name), quoted(DB_TABLE_META), quoted(DB_COLUMN_NAME.name), DB_COLUMN_NAME.placeholder);
  
     auto db = QSqlDatabase::database(DB_CONNECTION_NAME);
     QSqlQuery query {db};
  
     if (!query.prepare(selectDBVersionStatement))
         throw RuntimeError(query.lastError().text());
  
     query.bindValue(DB_COLUMN_NAME.placeholder, QString::fromLatin1(META_VERSION));
  
     if (!query.exec())
         throw RuntimeError(query.lastError().text());
  
     if (!query.next())
         throw RuntimeError(tr("Database is corrupted."));
  
     bool ok;
     const int dbVersion = query.value(0).toInt(&ok);
     if (!ok)
         throw RuntimeError(tr("Database is corrupted."));
  
     return dbVersion;
 }

Referenced by DBResumeDataStorage().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load()

std::optional< BitTorrent::LoadTorrentParams > BitTorrent::DBResumeDataStorage::load ( const TorrentID & id ) const

overridevirtual

Implements BitTorrent::ResumeDataStorage.

Definition at line 263 of file dbresumedatastorage.cpp.

 {
     const QString selectTorrentStatement =
             QString(QLatin1String("SELECT * FROM %1 WHERE %2 = %3;"))
             .arg(quoted(DB_TABLE_TORRENTS), quoted(DB_COLUMN_TORRENT_ID.name), DB_COLUMN_TORRENT_ID.placeholder);
  
     auto db = QSqlDatabase::database(DB_CONNECTION_NAME);
     QSqlQuery query {db};
     try
     {
         if (!query.prepare(selectTorrentStatement))
             throw RuntimeError(query.lastError().text());
  
         query.bindValue(DB_COLUMN_TORRENT_ID.placeholder, id.toString());
         if (!query.exec())
             throw RuntimeError(query.lastError().text());
  
         if (!query.next())
             throw RuntimeError(tr("Not found."));
     }
     catch (const RuntimeError &err)
     {
         LogMsg(tr("Couldn't load resume data of torrent '%1'. Error: %2")
             .arg(id.toString(), err.message()), Log::CRITICAL);
         return std::nullopt;
     }
  
     LoadTorrentParams resumeData;
     resumeData.restored = true;
     resumeData.name = query.value(DB_COLUMN_NAME.name).toString();
     resumeData.category = query.value(DB_COLUMN_CATEGORY.name).toString();
     const QString tagsData = query.value(DB_COLUMN_TAGS.name).toString();
     if (!tagsData.isEmpty())
     {
         const QStringList tagList = tagsData.split(QLatin1Char(','));
         resumeData.tags.insert(tagList.cbegin(), tagList.cend());
     }
     resumeData.hasSeedStatus = query.value(DB_COLUMN_HAS_SEED_STATUS.name).toBool();
     resumeData.firstLastPiecePriority = query.value(DB_COLUMN_HAS_OUTER_PIECES_PRIORITY.name).toBool();
     resumeData.ratioLimit = query.value(DB_COLUMN_RATIO_LIMIT.name).toInt() / 1000.0;
     resumeData.seedingTimeLimit = query.value(DB_COLUMN_SEEDING_TIME_LIMIT.name).toInt();
     resumeData.contentLayout = Utils::String::toEnum<TorrentContentLayout>(
                 query.value(DB_COLUMN_CONTENT_LAYOUT.name).toString(), TorrentContentLayout::Original);
     resumeData.operatingMode = Utils::String::toEnum<TorrentOperatingMode>(
                 query.value(DB_COLUMN_OPERATING_MODE.name).toString(), TorrentOperatingMode::AutoManaged);
     resumeData.stopped = query.value(DB_COLUMN_STOPPED.name).toBool();
  
     resumeData.savePath = Profile::instance()->fromPortablePath(
                 Utils::Fs::toUniformPath(query.value(DB_COLUMN_TARGET_SAVE_PATH.name).toString()));
     resumeData.useAutoTMM = resumeData.savePath.isEmpty();
     if (!resumeData.useAutoTMM)
     {
         resumeData.downloadPath = Profile::instance()->fromPortablePath(
                     Utils::Fs::toUniformPath(query.value(DB_COLUMN_DOWNLOAD_PATH.name).toString()));
     }
  
     const QByteArray bencodedResumeData = query.value(DB_COLUMN_RESUMEDATA.name).toByteArray();
     const QByteArray bencodedMetadata = query.value(DB_COLUMN_METADATA.name).toByteArray();
     const QByteArray allData = ((bencodedMetadata.isEmpty() || bencodedResumeData.isEmpty())
                                 ? bencodedResumeData
                                 : (bencodedResumeData.chopped(1) + bencodedMetadata.mid(1)));
  
     lt::error_code ec;
     const lt::bdecode_node root = lt::bdecode(allData, ec);
  
     resumeData.downloadPath = Profile::instance()->fromPortablePath(
                 Utils::Fs::toUniformPath(fromLTString(root.dict_find_string_value("qBt-downloadPath"))));
  
     lt::add_torrent_params &p = resumeData.ltAddTorrentParams;
  
     p = lt::read_resume_data(root, ec);
     p.save_path = Profile::instance()->fromPortablePath(fromLTString(p.save_path)).toStdString();
  
     return resumeData;
 }

Here is the call graph for this function:

◆ registeredTorrents()

QVector< BitTorrent::TorrentID > BitTorrent::DBResumeDataStorage::registeredTorrents ( ) const

overridevirtual

Implements BitTorrent::ResumeDataStorage.

Definition at line 244 of file dbresumedatastorage.cpp.

 {
     const auto selectTorrentIDStatement = QString::fromLatin1("SELECT %1 FROM %2 ORDER BY %3;")
             .arg(quoted(DB_COLUMN_TORRENT_ID.name), quoted(DB_TABLE_TORRENTS), quoted(DB_COLUMN_QUEUE_POSITION.name));
  
     auto db = QSqlDatabase::database(DB_CONNECTION_NAME);
     QSqlQuery query {db};
  
     if (!query.exec(selectTorrentIDStatement))
         throw RuntimeError(query.lastError().text());
  
     QVector<TorrentID> registeredTorrents;
     registeredTorrents.reserve(query.size());
     while (query.next())
         registeredTorrents.append(BitTorrent::TorrentID::fromString(query.value(0).toString()));
  
     return registeredTorrents;
 }

References anonymous_namespace{dbresumedatastorage.cpp}::DB_COLUMN_QUEUE_POSITION, anonymous_namespace{dbresumedatastorage.cpp}::DB_COLUMN_TORRENT_ID, anonymous_namespace{dbresumedatastorage.cpp}::DB_CONNECTION_NAME, anonymous_namespace{dbresumedatastorage.cpp}::DB_TABLE_TORRENTS, BitTorrent::TorrentID::fromString(), anonymous_namespace{dbresumedatastorage.cpp}::Column::name, and anonymous_namespace{dbresumedatastorage.cpp}::quoted().

Here is the call graph for this function:

◆ remove()

void BitTorrent::DBResumeDataStorage::remove ( const TorrentID & id ) const

overridevirtual

Implements BitTorrent::ResumeDataStorage.

Definition at line 347 of file dbresumedatastorage.cpp.

 {
     QMetaObject::invokeMethod(m_asyncWorker, [this, id]()
     {
         m_asyncWorker->remove(id);
     });
 }

◆ store()

void BitTorrent::DBResumeDataStorage::store	(	const TorrentID &	id,
		const LoadTorrentParams &	resumeData
	)		const

overridevirtual

Implements BitTorrent::ResumeDataStorage.

Definition at line 339 of file dbresumedatastorage.cpp.

 {
     QMetaObject::invokeMethod(m_asyncWorker, [this, id, resumeData]()
     {
         m_asyncWorker->store(id, resumeData);
     });
 }

◆ storeQueue()

void BitTorrent::DBResumeDataStorage::storeQueue ( const QVector< TorrentID > & queue ) const

overridevirtual

Implements BitTorrent::ResumeDataStorage.

Definition at line 355 of file dbresumedatastorage.cpp.

 {
     QMetaObject::invokeMethod(m_asyncWorker, [this, queue]()
     {
         m_asyncWorker->storeQueue(queue);
     });
 }

◆ updateDBFromVersion1()

void BitTorrent::DBResumeDataStorage::updateDBFromVersion1 ( ) const

private

Definition at line 452 of file dbresumedatastorage.cpp.

 {
     auto db = QSqlDatabase::database(DB_CONNECTION_NAME);
  
     if (!db.transaction())
         throw RuntimeError(db.lastError().text());
  
     QSqlQuery query {db};
  
     try
     {
         const auto alterTableTorrentsQuery = QString::fromLatin1("ALTER TABLE %1 ADD %2")
                 .arg(quoted(DB_TABLE_TORRENTS), makeColumnDefinition(DB_COLUMN_DOWNLOAD_PATH, "TEXT"));
         if (!query.exec(alterTableTorrentsQuery))
             throw RuntimeError(query.lastError().text());
  
         const QString updateMetaVersionQuery = makeUpdateStatement(DB_TABLE_META, {DB_COLUMN_NAME, DB_COLUMN_VALUE});
         if (!query.prepare(updateMetaVersionQuery))
             throw RuntimeError(query.lastError().text());
  
         query.bindValue(DB_COLUMN_NAME.placeholder, QString::fromLatin1(META_VERSION));
         query.bindValue(DB_COLUMN_VALUE.placeholder, DB_VERSION);
  
         if (!query.exec())
             throw RuntimeError(query.lastError().text());
  
         if (!db.commit())
             throw RuntimeError(db.lastError().text());
     }
     catch (const RuntimeError &)
     {
         db.rollback();
         throw;
     }
 }