Inheritance diagram for BitTorrent::BencodeResumeDataStorage::Worker:

Collaboration diagram for BitTorrent::BencodeResumeDataStorage::Worker:

Public Member Functions
	Worker (const QDir &resumeDataDir)

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

void	remove (const TorrentID &id) const

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

Private Attributes
const QDir	m_resumeDataDir

Detailed Description

Definition at line 56 of file bencoderesumedatastorage.cpp.

Constructor & Destructor Documentation

◆ Worker()

BitTorrent::BencodeResumeDataStorage::Worker::Worker ( const QDir & resumeDataDir )

explicit

Definition at line 309 of file bencoderesumedatastorage.cpp.

     : m_resumeDataDir {resumeDataDir}
 {
 }

Member Function Documentation

◆ remove()

void BitTorrent::BencodeResumeDataStorage::Worker::remove ( const TorrentID & id ) const

Definition at line 386 of file bencoderesumedatastorage.cpp.

 {
     const QString resumeFilename = QString::fromLatin1("%1.fastresume").arg(id.toString());
     Utils::Fs::forceRemove(m_resumeDataDir.absoluteFilePath(resumeFilename));
  
     const QString torrentFilename = QString::fromLatin1("%1.torrent").arg(id.toString());
     Utils::Fs::forceRemove(m_resumeDataDir.absoluteFilePath(torrentFilename));
 }

References Utils::Fs::forceRemove(), BitTorrent::BencodeResumeDataStorage::m_resumeDataDir, and anonymous_namespace{session.cpp}::toString().

Here is the call graph for this function:

◆ store()

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

Definition at line 314 of file bencoderesumedatastorage.cpp.

 {
     // We need to adjust native libtorrent resume data
     lt::add_torrent_params p = resumeData.ltAddTorrentParams;
     p.save_path = Profile::instance()->toPortablePath(QString::fromStdString(p.save_path)).toStdString();
     if (resumeData.stopped)
     {
         p.flags |= lt::torrent_flags::paused;
         p.flags &= ~lt::torrent_flags::auto_managed;
     }
     else
     {
         // Torrent can be actually "running" but temporarily "paused" to perform some
         // service jobs behind the scenes so we need to restore it as "running"
         if (resumeData.operatingMode == BitTorrent::TorrentOperatingMode::AutoManaged)
         {
             p.flags |= lt::torrent_flags::auto_managed;
         }
         else
         {
             p.flags &= ~lt::torrent_flags::paused;
             p.flags &= ~lt::torrent_flags::auto_managed;
         }
     }
  
     lt::entry data = lt::write_resume_data(p);
  
     // metadata is stored in separate .torrent file
     if (p.ti)
     {
         lt::entry::dictionary_type &dataDict = data.dict();
         lt::entry metadata {lt::entry::dictionary_t};
         lt::entry::dictionary_type &metadataDict = metadata.dict();
         metadataDict.insert(dataDict.extract("info"));
         metadataDict.insert(dataDict.extract("creation date"));
         metadataDict.insert(dataDict.extract("created by"));
         metadataDict.insert(dataDict.extract("comment"));
  
         const QString torrentFilepath = m_resumeDataDir.absoluteFilePath(QString::fromLatin1("%1.torrent").arg(id.toString()));
         const nonstd::expected<void, QString> result = Utils::IO::saveToFile(torrentFilepath, metadata);
         if (!result)
         {
             LogMsg(tr("Couldn't save torrent metadata to '%1'. Error: %2.")
                    .arg(torrentFilepath, result.error()), Log::CRITICAL);
             return;
         }
     }
  
     data["qBt-ratioLimit"] = static_cast<int>(resumeData.ratioLimit * 1000);
     data["qBt-seedingTimeLimit"] = resumeData.seedingTimeLimit;
     data["qBt-category"] = resumeData.category.toStdString();
     data["qBt-tags"] = setToEntryList(resumeData.tags);
     data["qBt-name"] = resumeData.name.toStdString();
     data["qBt-seedStatus"] = resumeData.hasSeedStatus;
     data["qBt-contentLayout"] = Utils::String::fromEnum(resumeData.contentLayout).toStdString();
     data["qBt-firstLastPiecePriority"] = resumeData.firstLastPiecePriority;
  
     if (!resumeData.useAutoTMM)
     {
         data["qBt-savePath"] = Profile::instance()->toPortablePath(resumeData.savePath).toStdString();
         data["qBt-downloadPath"] = Profile::instance()->toPortablePath(resumeData.downloadPath).toStdString();
     }
  
     const QString resumeFilepath = m_resumeDataDir.absoluteFilePath(QString::fromLatin1("%1.fastresume").arg(id.toString()));
     const nonstd::expected<void, QString> result = Utils::IO::saveToFile(resumeFilepath, data);
     if (!result)
     {
         LogMsg(tr("Couldn't save torrent resume data to '%1'. Error: %2.")
                .arg(resumeFilepath, result.error()), Log::CRITICAL);
     }
 }

Here is the call graph for this function:

◆ storeQueue()

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

Definition at line 395 of file bencoderesumedatastorage.cpp.

 {
     QByteArray data;
     data.reserve(((BitTorrent::TorrentID::length() * 2) + 1) * queue.size());
     for (const BitTorrent::TorrentID &torrentID : queue)
         data += (torrentID.toString().toLatin1() + '\n');
  
     const QString filepath = m_resumeDataDir.absoluteFilePath(QLatin1String("queue"));
     const nonstd::expected<void, QString> result = Utils::IO::saveToFile(filepath, data);
     if (!result)
     {
         LogMsg(tr("Couldn't save data to '%1'. Error: %2")
             .arg(filepath, result.error()), Log::CRITICAL);
     }
 }