Allow to cancel archives extraction

There is cancel button in extraction dialog, but there were no support for cancellation in underlying KArchive library. This commits adds interrupt support and fixes crash #289
variar · May 11, 2021 · cf1b845 · cf1b845
1 parent 385c7dc
commit cf1b845
Show file tree

Hide file tree

Showing 7 changed files with 184 additions and 102 deletions.
diff --git a/3rdparty/karchive/src/karchive.cpp b/3rdparty/karchive/src/karchive.cpp
@@ -834,7 +834,7 @@ static QFileDevice::Permissions withExecutablePerms(
     return filePerms;
 }
 
-bool KArchiveFile::copyTo(const QString &dest) const
+bool KArchiveFile::copyTo(const QString &dest, const QAtomicInt& isCanceled) const
 {
     QFile f(dest + QLatin1Char('/')  + name());
     if (f.open(QIODevice::ReadWrite | QIODevice::Truncate)) {
@@ -851,6 +851,9 @@ bool KArchiveFile::copyTo(const QString &dest) const
         array.resize(int(qMin(chunkSize, remainingSize)));
 
         while (remainingSize > 0) {
+            if (isCanceled.loadAcquire() != 0) {
+                break;
+            }
             const qint64 currentChunkSize = qMin(chunkSize, remainingSize);
             const qint64 n = inputDev->read(array.data(), currentChunkSize);
             Q_UNUSED(n) // except in Q_ASSERT
@@ -862,7 +865,7 @@ bool KArchiveFile::copyTo(const QString &dest) const
         f.close();
 
         delete inputDev;
-        return true;
+        return isCanceled.loadAcquire() == 0;
     }
     return false;
 }
@@ -953,7 +956,7 @@ static bool sortByPosition(const KArchiveFile *file1, const KArchiveFile *file2)
     return file1->position() < file2->position();
 }
 
-bool KArchiveDirectory::copyTo(const QString &dest, bool recursiveCopy) const
+bool KArchiveDirectory::copyTo(const QString &dest, const QAtomicInt& isCanceled, bool recursiveCopy) const
 {
     QDir root;
     const QString destDir(QDir(dest).absolutePath()); // get directory path without any "." or ".."
@@ -1025,7 +1028,7 @@ bool KArchiveDirectory::copyTo(const QString &dest, bool recursiveCopy) const
          it != end; ++it) {
         const KArchiveFile *f = *it;
         qint64 pos = f->position();
-        if (!f->copyTo(fileToDir[pos])) {
+        if (!f->copyTo(fileToDir[pos], isCanceled)) {
             return false;
         }
     }

diff --git a/3rdparty/karchive/src/karchivedirectory.h b/3rdparty/karchive/src/karchivedirectory.h
@@ -24,6 +24,7 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 
+#include <QAtomicInt>
 #include <QDate>
 #include <QString>
 #include <QStringList>
@@ -122,7 +123,7 @@ class KARCHIVE_EXPORT KArchiveDirectory : public KArchiveEntry
      * @param recursive if set to true, subdirectories are extracted as well
      * @return true on success, false if the directory (dest + '/' + name()) couldn't be created
      */
-    bool copyTo(const QString &dest, bool recursive = true) const;
+    bool copyTo(const QString &dest, const QAtomicInt& isCanceled, bool recursive = true) const;
 
 protected:
     void virtual_hook(int id, void *data) override;

diff --git a/3rdparty/karchive/src/karchivefile.h b/3rdparty/karchive/src/karchivefile.h
@@ -21,6 +21,8 @@
 #ifndef KARCHIVEFILE_H
 #define KARCHIVEFILE_H
 
+#include <QAtomicInt>
+
 #include <karchiveentry.h>
 
 class KArchiveFilePrivate;
@@ -103,7 +105,7 @@ class KARCHIVE_EXPORT KArchiveFile : public KArchiveEntry
      * @param dest the directory to extract to
      * @return true on success, false if the file (dest + '/' + name()) couldn't be created
      */
-    bool copyTo(const QString &dest) const;
+    bool copyTo(const QString &dest, const QAtomicInt& isCanceled) const;
 
 protected:
     void virtual_hook(int id, void *data) override;

diff --git a/src/ui/src/mainwindow.cpp b/src/ui/src/mainwindow.cpp
diff --git a/src/utils/include/atomicflag.h b/src/utils/include/atomicflag.h
@@ -69,6 +69,11 @@ class AtomicFlag {
         return !flag_.loadAcquire();
     }
 
+    operator const QAtomicInt&() const
+    {
+        return flag_;
+    }
+
   private:
     QAtomicInt flag_;
 };

diff --git a/src/utils/include/decompressor.h b/src/utils/include/decompressor.h
@@ -23,18 +23,21 @@
 #include <QFuture>
 #include <QFutureWatcher>
 
+#include "atomicflag.h"
 
-enum class DecompressAction {None, Extract, Decompress};
+enum class DecompressAction { None, Extract, Decompress };
 class Decompressor : public QObject {
     Q_OBJECT
   public:
     explicit Decompressor( QObject* parent = nullptr );
 
-    bool decompress( const QString& path, QFile* outputFile );
-    bool extract( const QString& archiveFilePath, const QString& destination );
+    bool decompress( const QString& path, QFile* outputFile, AtomicFlag& interrupt );
+    bool extract( const QString& archiveFilePath, const QString& destination,
+                  AtomicFlag& interrupt );
 
+    bool waitForResult();
 
-    static DecompressAction action(const QString& archiveFilePath );
+    static DecompressAction action( const QString& archiveFilePath );
 
   signals:
     void finished( bool );

diff --git a/src/utils/src/decompressor.cpp b/src/utils/src/decompressor.cpp
@@ -161,17 +161,92 @@ std::shared_ptr<KCompressionDevice> makeDecompressor( Archive archiveType,
     }
 }
 
+bool doExtract( std::shared_ptr<KArchive> archive, const QString& archiveFilePath,
+                const QString& destination, AtomicFlag& interrupt )
+{
+    if ( !archive->open( QIODevice::ReadOnly ) ) {
+        LOG_WARNING << "Cannot open " << archiveFilePath;
+        return false;
+    }
+
+    const KArchiveDirectory* root = archive->directory();
+
+    if ( !root ) {
+        LOG_WARNING << "Cannot open root directory" << archiveFilePath;
+        archive->close();
+        return false;
+    }
+
+    auto result = false;
+    try {
+        const auto recursive = true;
+        result = root->copyTo( destination, interrupt, recursive );
+    } catch ( const std::exception& e ) {
+        LOG_ERROR << "Exception during extract: " << e.what();
+    }
+
+    if ( interrupt ) {
+        result = false;
+        LOG_INFO << "Interrupted extract of " << archiveFilePath;
+    }
+
+    archive->close();
+    return result;
+}
+
+bool doDecompress( std::shared_ptr<KCompressionDevice> input, const QString& archiveFilePath,
+                   QFile* outputFile, AtomicFlag& interrupt )
+{
+    if ( !input->open( QIODevice::ReadOnly ) ) {
+        LOG_WARNING << "Cannot open " << archiveFilePath;
+        return false;
+    }
+
+    bool success = true;
+    try {
+        while ( !input->atEnd() ) {
+            if ( interrupt ) {
+                success = false;
+                LOG_INFO << "Interrupted decompress of " << archiveFilePath;
+                break;
+            }
+
+            QByteArray data = input->read( 4 * 1024 * 1024 );
+            if ( data.size() > 0 ) {
+                const auto writtenBytes = outputFile->write( data );
+                if ( writtenBytes < 0 ) {
+                    LOG_ERROR << "Error decompressing " << archiveFilePath;
+                    success = false;
+                    break;
+                }
+            }
+        }
+    } catch ( const std::exception& e ) {
+        LOG_ERROR << "Exception during decompress: " << e.what();
+    }
+
+    input->close();
+    outputFile->close();
+
+    return success;
+}
+
 } // namespace
 
 Decompressor::Decompressor( QObject* parent )
     : QObject( parent )
 {
-    connect( &watcher_, &QFutureWatcher<bool>::finished, [this]() {
+    connect( &watcher_, &QFutureWatcher<bool>::finished, [ this ]() {
         LOG_INFO << "Decompressor finished " << watcher_.result();
         emit finished( watcher_.result() );
     } );
 }
 
+bool Decompressor::waitForResult()
+{
+    return watcher_.result();
+}
+
 DecompressAction Decompressor::action( const QString& archiveFilePath )
 {
     const auto archive = archiveType( archiveFilePath );
@@ -190,44 +265,26 @@ DecompressAction Decompressor::action( const QString& archiveFilePath )
     }
 }
 
-bool Decompressor::decompress( const QString& archiveFilePath, QFile* outputFile )
+bool Decompressor::decompress( const QString& archiveFilePath, QFile* outputFile,
+                               AtomicFlag& interrupt )
 {
     auto decompressor = makeDecompressor( archiveType( archiveFilePath ), archiveFilePath );
     if ( !decompressor ) {
         LOG_WARNING << "Unsupported archive " << archiveFilePath.constData();
         return false;
     }
 
-    future_ = QtConcurrent::run( [input = std::move( decompressor ), archiveFilePath, outputFile] {
-        if ( !input->open( QIODevice::ReadOnly ) ) {
-            LOG_WARNING << "Cannot open " << archiveFilePath;
-            return false;
-        }
-
-        bool success = true;
-        while ( !input->atEnd() ) {
-            QByteArray data = input->read( 1024 * 1024 );
-            if ( data.size() > 0 ) {
-                const auto writtenBytes = outputFile->write( data );
-                if ( writtenBytes < 0 ) {
-                    LOG_ERROR << "Error decompressing " << archiveFilePath;
-                    success = false;
-                    break;
-                }
-            }
-        }
-        input->close();
-        outputFile->close();
-
-        return success;
-    } );
-
+    future_ = QtConcurrent::run(
+        [ input = std::move( decompressor ), archiveFilePath, outputFile, &interrupt ] {
+            return doDecompress( input, archiveFilePath, outputFile, interrupt );
+        } );
     watcher_.setFuture( future_ );
 
     return true;
 }
 
-bool Decompressor::extract( const QString& archiveFilePath, const QString& destination )
+bool Decompressor::extract( const QString& archiveFilePath, const QString& destination,
+                            AtomicFlag& interrupt )
 {
     auto archive = makeExtractor( archiveType( archiveFilePath ), archiveFilePath );
     if ( !archive ) {
@@ -237,19 +294,10 @@ bool Decompressor::extract( const QString& archiveFilePath, const QString& desti
 
     // Open the archive
 
-    future_ = QtConcurrent::run( [ar = std::move( archive ), archiveFilePath, destination] {
-        if ( !ar->open( QIODevice::ReadOnly ) ) {
-            LOG_WARNING << "Cannot open " << archiveFilePath;
-            return false;
-        }
-
-        const KArchiveDirectory* root = ar->directory();
-        const auto recursive = true;
-        const auto result = root->copyTo( destination, recursive );
-        ar->close();
-        return result;
-    } );
-
+    future_ = QtConcurrent::run(
+        [ ar = std::move( archive ), archiveFilePath, destination, &interrupt ] {
+            return doExtract( ar, archiveFilePath, destination, interrupt );
+        } );
     watcher_.setFuture( future_ );
 
     return true;