Fixes #2120

Author: mycir

src/vorta/application.py

@@ -2,6 +2,7 @@
 import os
 import sys
 from pathlib import Path
+from threading import Thread
 from typing import Any, Dict, List, Tuple
 
 from PyQt6 import QtCore
@@ -42,6 +43,9 @@ 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)
 
     def __init__(self, args_raw, single_app=False):
         super().__init__(str(APP_ID), args_raw)
@@ -84,6 +88,9 @@ 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)
         self.set_borg_details_action()
         if sys.platform == 'darwin':
@@ -94,7 +101,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}")
-            self.create_backup_action(profile_id=profile.id)
+            Thread(target=self.create_backup_action, kwargs={'profile_id': profile.id}).start()
         else:
             logger.warning(f"Invalid profile name {profile_name}")
 
@@ -110,7 +117,7 @@ def create_backup_action(self, profile_id=None):
             profile_id = self.main_window.current_profile.id
 
         profile = BackupProfileModel.get(id=profile_id)
-        msg = BorgCreateJob.prepare(profile)
+        msg = BorgCreateJob.prepare(profile, app=self)
         if msg['ok']:
             job = BorgCreateJob(msg['cmd'], msg, profile.repo.id)
             self.jobs_manager.add_job(job)
@@ -146,6 +153,13 @@ def backup_cancelled_event_response(self):
         self.jobs_manager.cancel_all_jobs()
         self.tray.set_tray_icon()
 
+    def pre_backup_event_response(self, pid):
+        self.tray.set_tray_icon(active=True)
+
+    def post_backup_event_response(self, pid, active=False):
+        if not active:
+            self.tray.set_tray_icon()
+
     def message_received_event_response(self, message):
         if message == "open main window":
             self.open_main_window_action()

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):
+    def progress_event(self, fmt=None):
         self.app.backup_progress_event.emit(f"[{self.params['profile_name']}] {fmt}")
 
     def started_event(self):
@@ -63,26 +63,34 @@ def started_event(self):
     def finished_event(self, result):
         self.app.backup_finished_event.emit(result)
         self.result.emit(result)
-        self.pre_post_backup_cmd(self.params, cmd='post_backup_cmd', returncode=result['returncode'])
+        self.pre_post_backup_cmd(self.params, context='post_backup_cmd', app=self.app, returncode=result['returncode'])
 
     @classmethod
-    def pre_post_backup_cmd(cls, params, cmd='pre_backup_cmd', returncode=0):
-        cmd = getattr(params['profile'], cmd)
+    def pre_post_backup_cmd(cls, params, context='pre_backup_cmd', app=None, returncode=0):
+        cmd = getattr(params['profile'], context)
         if cmd:
+            profile_name = getattr(params['profile'], 'name')
             env = {
                 **os.environ.copy(),
                 'repo_url': params['repo'].url,
                 'profile_name': params['profile'].name,
                 'profile_slug': params['profile'].slug(),
                 'returncode': str(returncode),
             }
-            proc = subprocess.run(cmd, shell=True, env=env)
+            proc = subprocess.Popen(cmd, shell=True, env=env)
+            if context.startswith('pre'):
+                app.backup_progress_event.emit(f"[{profile_name}] {trans_late('messages', 'Waiting to start backup')}")
+                app.pre_backup_event.emit(proc.pid)
+            else:
+                app.post_backup_event.emit(proc.pid, True)
+            proc.wait()
+            app.post_backup_event.emit(None, False)
             return proc.returncode
         else:
             return 0  # 0 if no command was run.
 
     @classmethod
-    def prepare(cls, profile):
+    def prepare(cls, profile, app=None):
         """
         `borg create` is called from different places and needs some preparation.
         Centralize it here and return the required arguments to the caller.
@@ -133,7 +141,7 @@ def prepare(cls, profile):
         ret['repo'] = profile.repo
 
         # Run user-supplied pre-backup command
-        if cls.pre_post_backup_cmd(ret) != 0:
+        if cls.pre_post_backup_cmd(ret, app=app) != 0:
             ret['message'] = trans_late('messages', 'Pre-backup command returned non-zero exit code.')
             return ret
 

src/vorta/scheduler.py

@@ -301,7 +301,7 @@ def set_timer_for_profile(self, profile_id: int):
                             profile.name,
                             profile_id,
                         )
-                        self.create_backup(profile_id)
+                        threading.Thread(target=self.create_backup, args=(profile_id,)).start()
                     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: self.create_backup(profile_id))
+                timer.timeout.connect(lambda: threading.Thread(target=self.create_backup, args=(profile_id,)).start())
                 timer.start()
 
                 self.timers[profile_id] = {
@@ -410,7 +410,7 @@ def create_backup(self, profile_id):
                 self.tr('Starting background backup for %s.') % profile.name,
                 level='info',
             )
-            msg = BorgCreateJob.prepare(profile)
+            msg = BorgCreateJob.prepare(profile, app=self.app)
             if msg['ok']:
                 logger.info('Preparation for backup successful.')
                 msg['category'] = 'scheduled'

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_action)
+        self.createStartBtn.clicked.connect(self.app.create_backup_event.emit)
         self.cancelButton.clicked.connect(self.app.backup_cancelled_event.emit)
 
         QShortcut(QKeySequence("Ctrl+W"), self).activated.connect(self.on_close_window)
@@ -99,6 +99,8 @@ def __init__(self, parent=None):
         self.app.backup_log_event.connect(self.set_log)
         self.app.backup_progress_event.connect(self.set_progress)
         self.app.backup_cancelled_event.connect(self.backup_cancelled_event)
+        self.app.pre_backup_event.connect(self.pre_backup_event)
+        self.app.post_backup_event.connect(self.post_backup_event)
 
         # Init profile list
         self.populate_profile_selector()
@@ -339,6 +341,17 @@ def backup_cancelled_event(self):
         self.set_log(self.tr('Task cancelled'))
         self.archiveTab.cancel_action()
 
+    def pre_backup_event(self, pid):
+        self._toggle_buttons(create_enabled=False)
+        self.set_log(self.tr(f"Running pre backup commands [PID: {pid}]"))
+
+    def post_backup_event(self, pid, active=True):
+        if active:
+            self.set_log(self.tr(f"Running post backup commands [PID: {pid}]"))
+        else:
+            self._toggle_buttons(create_enabled=True)
+            self.set_log('')
+
     def closeEvent(self, event):
         # Save window state in SettingsModel
         SettingsModel.update({SettingsModel.str_value: str(self.width())}).where(