filemanager.cpp Example File

 /****************************************************************************
 **
 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the examples of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:BSD$
 ** You may use this file under the terms of the BSD license as follows:
 **
 ** "Redistribution and use in source and binary forms, with or without
 ** modification, are permitted provided that the following conditions are
 ** met:
 **   * Redistributions of source code must retain the above copyright
 **     notice, this list of conditions and the following disclaimer.
 **   * Redistributions in binary form must reproduce the above copyright
 **     notice, this list of conditions and the following disclaimer in
 **     the documentation and/or other materials provided with the
 **     distribution.
 **   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
 **     the names of its contributors may be used to endorse or promote
 **     products derived from this software without specific prior written
 **     permission.
 **
 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include "filemanager.h"
 #include "metainfo.h"

 #include <QByteArray>
 #include <QDir>
 #include <QFile>
 #include <QTimer>
 #include <QTimerEvent>
 #include <QCryptographicHash>

 FileManager::FileManager(QObject *parent)
     : QThread(parent)
 {
     quit = false;
     totalLength = 0;
     readId = 0;
     startVerification = false;
     wokeUp = false;
     newFile = false;
     numPieces = 0;
     verifiedPieces.fill(false);
 }

 FileManager::~FileManager()
 {
     quit = true;
     cond.wakeOne();
     wait();

     foreach (QFile *file, files) {
         file->close();
         delete file;
     }
 }

 int FileManager::read(int pieceIndex, int offset, int length)
 {
     ReadRequest request;
     request.pieceIndex = pieceIndex;
     request.offset = offset;
     request.length = length;

     QMutexLocker locker(&mutex);
     request.id = readId++;
     readRequests << request;

     if (!wokeUp) {
         wokeUp = true;
         QMetaObject::invokeMethod(this, "wakeUp", Qt::QueuedConnection);
     }

     return request.id;
 }

 void FileManager::write(int pieceIndex, int offset, const QByteArray &data)
 {
     WriteRequest request;
     request.pieceIndex = pieceIndex;
     request.offset = offset;
     request.data = data;

     QMutexLocker locker(&mutex);
     writeRequests << request;

     if (!wokeUp) {
         wokeUp = true;
         QMetaObject::invokeMethod(this, "wakeUp", Qt::QueuedConnection);
     }
 }

 void FileManager::verifyPiece(int pieceIndex)
 {
     QMutexLocker locker(&mutex);
     pendingVerificationRequests << pieceIndex;
     startVerification = true;

     if (!wokeUp) {
         wokeUp = true;
         QMetaObject::invokeMethod(this, "wakeUp", Qt::QueuedConnection);
     }
 }

 int FileManager::pieceLengthAt(int pieceIndex) const
 {
     QMutexLocker locker(&mutex);
     return (sha1s.size() == pieceIndex + 1)
         ? (totalLength % pieceLength) : pieceLength;
 }

 QBitArray FileManager::completedPieces() const
 {
     QMutexLocker locker(&mutex);
     return verifiedPieces;
 }

 void FileManager::setCompletedPieces(const QBitArray &pieces)
 {
     QMutexLocker locker(&mutex);
     verifiedPieces = pieces;
 }

 QString FileManager::errorString() const
 {
     return errString;
 }

 void FileManager::run()
 {
     if (!generateFiles())
         return;

     do {
         {
             // Go to sleep if there's nothing to do.
             QMutexLocker locker(&mutex);
             if (!quit && readRequests.isEmpty() && writeRequests.isEmpty() && !startVerification)
                 cond.wait(&mutex);
         }

         // Read pending read requests
         mutex.lock();
         QList<ReadRequest> newReadRequests = readRequests;
         readRequests.clear();
         mutex.unlock();
         while (!newReadRequests.isEmpty()) {
             ReadRequest request = newReadRequests.takeFirst();
             QByteArray block = readBlock(request.pieceIndex, request.offset, request.length);
             emit dataRead(request.id, request.pieceIndex, request.offset, block);
         }

         // Write pending write requests
         mutex.lock();
         QList<WriteRequest> newWriteRequests = writeRequests;
         writeRequests.clear();
         while (!quit && !newWriteRequests.isEmpty()) {
             WriteRequest request = newWriteRequests.takeFirst();
             writeBlock(request.pieceIndex, request.offset, request.data);
         }

         // Process pending verification requests
         if (startVerification) {
             newPendingVerificationRequests = pendingVerificationRequests;
             pendingVerificationRequests.clear();
             verifyFileContents();
             startVerification = false;
         }
         mutex.unlock();
         newPendingVerificationRequests.clear();

     } while (!quit);

     // Write pending write requests
     mutex.lock();
     QList<WriteRequest> newWriteRequests = writeRequests;
     writeRequests.clear();
     mutex.unlock();
     while (!newWriteRequests.isEmpty()) {
         WriteRequest request = newWriteRequests.takeFirst();
         writeBlock(request.pieceIndex, request.offset, request.data);
     }
 }

 void FileManager::startDataVerification()
 {
     QMutexLocker locker(&mutex);
     startVerification = true;
     cond.wakeOne();
 }

 bool FileManager::generateFiles()
 {
     numPieces = -1;

     // Set up the thread local data
     if (metaInfo.fileForm() == MetaInfo::SingleFileForm) {
         QMutexLocker locker(&mutex);
         MetaInfoSingleFile singleFile = metaInfo.singleFile();

         QString prefix;
         if (!destinationPath.isEmpty()) {
             prefix = destinationPath;
             if (!prefix.endsWith("/"))
                 prefix += "/";
             QDir dir;
             if (!dir.mkpath(prefix)) {
                 errString = tr("Failed to create directory %1").arg(prefix);
                 emit error();
                 return false;
             }
         }
         QFile *file = new QFile(prefix + singleFile.name);
         if (!file->open(QFile::ReadWrite)) {
             errString = tr("Failed to open/create file %1: %2")
                         .arg(file->fileName()).arg(file->errorString());
             emit error();
             return false;
         }

         if (file->size() != singleFile.length) {
             newFile = true;
             if (!file->resize(singleFile.length)) {
                 errString = tr("Failed to resize file %1: %2")
                             .arg(file->fileName()).arg(file->errorString());
                 emit error();
                 return false;
             }
         }
         fileSizes << file->size();
         files << file;
         file->close();

         pieceLength = singleFile.pieceLength;
         totalLength = singleFile.length;
         sha1s = singleFile.sha1Sums;
     } else {
         QMutexLocker locker(&mutex);
         QDir dir;
         QString prefix;

         if (!destinationPath.isEmpty()) {
             prefix = destinationPath;
             if (!prefix.endsWith("/"))
                 prefix += "/";
         }
         if (!metaInfo.name().isEmpty()) {
             prefix += metaInfo.name();
             if (!prefix.endsWith("/"))
                 prefix += "/";
         }
         if (!dir.mkpath(prefix)) {
             errString = tr("Failed to create directory %1").arg(prefix);
             emit error();
             return false;
         }

         foreach (const MetaInfoMultiFile &entry, metaInfo.multiFiles()) {
             QString filePath = QFileInfo(prefix + entry.path).path();
             if (!QFile::exists(filePath)) {
                 if (!dir.mkpath(filePath)) {
                     errString = tr("Failed to create directory %1").arg(filePath);
                     emit error();
                     return false;
                 }
             }

             QFile *file = new QFile(prefix + entry.path);
             if (!file->open(QFile::ReadWrite)) {
                 errString = tr("Failed to open/create file %1: %2")
                             .arg(file->fileName()).arg(file->errorString());
                 emit error();
                 return false;
             }

             if (file->size() != entry.length) {
                 newFile = true;
                 if (!file->resize(entry.length)) {
                     errString = tr("Failed to resize file %1: %2")
                                 .arg(file->fileName()).arg(file->errorString());
                     emit error();
                     return false;
                 }
             }
             fileSizes << file->size();
             files << file;
             file->close();

             totalLength += entry.length;
         }

         sha1s = metaInfo.sha1Sums();
         pieceLength = metaInfo.pieceLength();
     }
     numPieces = sha1s.size();
     return true;
 }

 QByteArray FileManager::readBlock(int pieceIndex, int offset, int length)
 {
     QByteArray block;
     qint64 startReadIndex = (quint64(pieceIndex) * pieceLength) + offset;
     qint64 currentIndex = 0;

     for (int i = 0; !quit && i < files.size() && length > 0; ++i) {
         QFile *file = files[i];
         qint64 currentFileSize = fileSizes.at(i);
         if ((currentIndex + currentFileSize) > startReadIndex) {
             if (!file->isOpen()) {
                 if (!file->open(QFile::ReadWrite)) {
                     errString = tr("Failed to read from file %1: %2")
                         .arg(file->fileName()).arg(file->errorString());
                     emit error();
                     break;
                 }
             }

             file->seek(startReadIndex - currentIndex);
             QByteArray chunk = file->read(qMin<qint64>(length, currentFileSize - file->pos()));
             file->close();

             block += chunk;
             length -= chunk.size();
             startReadIndex += chunk.size();
             if (length < 0) {
                 errString = tr("Failed to read from file %1 (read %3 bytes): %2")
                             .arg(file->fileName()).arg(file->errorString()).arg(length);
                 emit error();
                 break;
             }
         }
         currentIndex += currentFileSize;
     }
     return block;
 }

 bool FileManager::writeBlock(int pieceIndex, int offset, const QByteArray &data)
 {
     qint64 startWriteIndex = (qint64(pieceIndex) * pieceLength) + offset;
     qint64 currentIndex = 0;
     int bytesToWrite = data.size();
     int written = 0;

     for (int i = 0; !quit && i < files.size(); ++i) {
         QFile *file = files[i];
         qint64 currentFileSize = fileSizes.at(i);

         if ((currentIndex + currentFileSize) > startWriteIndex) {
             if (!file->isOpen()) {
                 if (!file->open(QFile::ReadWrite)) {
                     errString = tr("Failed to write to file %1: %2")
                         .arg(file->fileName()).arg(file->errorString());
                     emit error();
                     break;
                 }
             }

             file->seek(startWriteIndex - currentIndex);
             qint64 bytesWritten = file->write(data.constData() + written,
                                               qMin<qint64>(bytesToWrite, currentFileSize - file->pos()));
             file->close();

             if (bytesWritten <= 0) {
                 errString = tr("Failed to write to file %1: %2")
                             .arg(file->fileName()).arg(file->errorString());
                 emit error();
                 return false;
             }

             written += bytesWritten;
             startWriteIndex += bytesWritten;
             bytesToWrite -= bytesWritten;
             if (bytesToWrite == 0)
                 break;
         }
         currentIndex += currentFileSize;
     }
     return true;
 }

 void FileManager::verifyFileContents()
 {
     // Verify all pieces the first time
     if (newPendingVerificationRequests.isEmpty()) {
         if (verifiedPieces.count(true) == 0) {
             verifiedPieces.resize(sha1s.size());

             int oldPercent = 0;
             if (!newFile) {
                 int numPieces = sha1s.size();

                 for (int index = 0; index < numPieces; ++index) {
                     verifySinglePiece(index);

                     int percent = ((index + 1) * 100) / numPieces;
                     if (oldPercent != percent) {
                         emit verificationProgress(percent);
                         oldPercent = percent;
                     }
                 }
             }
         }
         emit verificationDone();
         return;
     }

     // Verify all pending pieces
     foreach (int index, newPendingVerificationRequests)
         emit pieceVerified(index, verifySinglePiece(index));
 }

 bool FileManager::verifySinglePiece(int pieceIndex)
 {
     QByteArray block = readBlock(pieceIndex, 0, pieceLength);
     QByteArray sha1Sum = QCryptographicHash::hash(block, QCryptographicHash::Sha1);

     if (sha1Sum != sha1s.at(pieceIndex))
         return false;
     verifiedPieces.setBit(pieceIndex);
     return true;
 }

 void FileManager::wakeUp()
 {
     QMutexLocker locker(&mutex);
     wokeUp = false;
     cond.wakeOne();
 }