Fixes #2120 (ammended)

Author: mycir

src/vorta/application.py

@@ -2,7 +2,6 @@
 import os
 import sys
 from pathlib import Path
-from threading import Thread
 from typing import Any, Dict, List, Tuple
 
 from PyQt6 import QtCore
@@ -21,7 +20,7 @@
 from vorta.store.connection import cleanup_db
 from vorta.store.models import BackupProfileModel, SettingsModel
 from vorta.tray_menu import TrayMenu
-from vorta.utils import borg_compat, parse_args
+from vorta.utils import borg_compat, parse_args, AsyncRunner
 from vorta.views.main_window import MainWindow
 
 logger = logging.getLogger(__name__)
@@ -43,7 +42,6 @@ class VortaApp(QtSingleApplication):
     backup_log_event = QtCore.pyqtSignal(str, dict)
     backup_progress_event = QtCore.pyqtSignal(str)
     check_failed_event = QtCore.pyqtSignal(dict)
-    create_backup_event = QtCore.pyqtSignal()
     pre_backup_event = QtCore.pyqtSignal(int)
     post_backup_event = QtCore.pyqtSignal(int, bool)
 
@@ -88,7 +86,6 @@ def __init__(self, args_raw, single_app=False):
         self.message_received_event.connect(self.message_received_event_response)
         self.check_failed_event.connect(self.check_failed_response)
         self.backup_log_event.connect(self.react_to_log)
-        self.create_backup_event.connect(lambda: Thread(target=self.create_backup_action).start())
         self.pre_backup_event.connect(self.pre_backup_event_response)
         self.post_backup_event.connect(self.post_backup_event_response)
         self.aboutToQuit.connect(self.quit_app_action)
@@ -101,7 +98,7 @@ def create_backups_cmdline(self, profile_name):
         if profile is not None:
             if profile.repo is None:
                 logger.warning(f"Add a repository to {profile_name}")
-            Thread(target=self.create_backup_action, kwargs={'profile_id': profile.id}).start()
+            self.create_backup_action(profile_id=profile.id)
         else:
             logger.warning(f"Invalid profile name {profile_name}")
 
@@ -112,7 +109,8 @@ def quit_app_action(self):
         del self.tray
         cleanup_db()
 
-    def create_backup_action(self, profile_id=None):
+    @AsyncRunner
+    def create_backup_action(self, profile_id=None, app=None):
         if not profile_id:
             profile_id = self.main_window.current_profile.id
 

src/vorta/borg/create.py

@@ -53,7 +53,7 @@ def process_result(self, result):
                 self.app.backup_log_event.emit('', {})
                 self.app.backup_progress_event.emit(f"[{self.params['profile_name']}] {self.tr('Backup finished.')}")
 
-    def progress_event(self, fmt=None):
+    def progress_event(self, fmt):
         self.app.backup_progress_event.emit(f"[{self.params['profile_name']}] {fmt}")
 
     def started_event(self):

src/vorta/scheduler.py

@@ -19,7 +19,7 @@
 from vorta.i18n import translate
 from vorta.notifications import VortaNotifications
 from vorta.store.models import BackupProfileModel, EventLogModel
-from vorta.utils import borg_compat
+from vorta.utils import borg_compat, AsyncRunner
 
 logger = logging.getLogger(__name__)
 
@@ -301,7 +301,7 @@ def set_timer_for_profile(self, profile_id: int):
                             profile.name,
                             profile_id,
                         )
-                        threading.Thread(target=self.create_backup, args=(profile_id,)).start()
+                        self.create_backup(profile_id)
                     finally:
                         self.lock.acquire()  # with-statement will try to release
 
@@ -337,7 +337,7 @@ def set_timer_for_profile(self, profile_id: int):
                 timer = QTimer()
                 timer.setSingleShot(True)
                 timer.setInterval(int(timer_ms))
-                timer.timeout.connect(lambda: threading.Thread(target=self.create_backup, args=(profile_id,)).start())
+                timer.timeout.connect(lambda: self.create_backup(profile_id))
                 timer.start()
 
                 self.timers[profile_id] = {
@@ -389,6 +389,7 @@ def next_job_for_profile(self, profile_id: int) -> ScheduleStatus:
             return ScheduleStatus(ScheduleStatusType.UNSCHEDULED)
         return ScheduleStatus(job['type'], time=job.get('dt'))
 
+    @AsyncRunner
     def create_backup(self, profile_id):
         notifier = VortaNotifications.pick()
         profile = BackupProfileModel.get_or_none(id=profile_id)

src/vorta/utils.py

@@ -14,7 +14,7 @@
 
 import psutil
 from PyQt6 import QtCore
-from PyQt6.QtCore import QFileInfo, QThread, pyqtSignal
+from PyQt6.QtCore import QFileInfo, QObject, QThread, pyqtSignal
 from PyQt6.QtWidgets import QApplication, QFileDialog, QSystemTrayIcon
 
 from vorta.borg._compatibility import BorgCompatibility
@@ -31,6 +31,51 @@
 _network_status_monitor = None
 
 
+class AsyncRunner(QObject):
+    '''
+    Wrapper to run functions asynchronously from GUI thread, based on
+    https://gist.github.com/andgineer/026a617528c5740da24ec984ac282ee6#file-universal_decorator-py
+
+    NB Only apply it to void functions, otherwise return values will be lost.
+    '''
+    runner_thread = None
+
+    def __init__(self, orig_func):
+        super(AsyncRunner, self).__init__()
+        self.orig_func = orig_func
+        self.__name__ = "AsyncRunner"
+
+    def __call__(self, *args):
+        return self.orig_func(*args)
+
+    def __get__(self, wrapped_instance, owner):
+        return AsyncRunner.Helper(self, wrapped_instance)
+
+    class Helper(QObject):
+        def __init__(self, decorator_instance, wrapped_instance):
+            super(AsyncRunner.Helper, self).__init__()
+            self.decorator_instance = decorator_instance
+            self.wrapped_instance = wrapped_instance
+
+        def __call__(self, *args, **kwargs):
+            global runner_thread
+            runner_thread = AsyncRunner.Runner(self.decorator_instance, self.wrapped_instance, *args, **kwargs)
+            runner_thread.start()
+
+    class Runner(QtCore.QThread):
+        def __init__(self, decorator_instance, wrapped_instance, *args, **kwargs):
+            QtCore.QThread.__init__(self)
+            self.decorator_instance = decorator_instance
+            self.wrapped_instance = wrapped_instance
+            self.args = args
+            self.kwargs = kwargs
+
+        def run(self):
+            self.decorator_instance(self.wrapped_instance, *self.args, **self.kwargs)
+            self.terminate()
+            self.wait()
+
+
 class FilePathInfoAsync(QThread):
     signal = pyqtSignal(str, str, str)
 

src/vorta/views/main_window.py

@@ -88,7 +88,7 @@ def __init__(self, parent=None):
         self.miscTab.refresh_archive.connect(self.archiveTab.populate_from_profile)
 
         self.miscButton.clicked.connect(self.toggle_misc_visibility)
-        self.createStartBtn.clicked.connect(self.app.create_backup_event.emit)
+        self.createStartBtn.clicked.connect(self.app.create_backup_action)
         self.cancelButton.clicked.connect(self.app.backup_cancelled_event.emit)
 
         QShortcut(QKeySequence("Ctrl+W"), self).activated.connect(self.on_close_window)