fix: address swallowed exceptions and blocking calls

- config.py: log warning instead of silently swallowing callback errors
- core.py: move os.statvfs (get_free_space) to thread to avoid blocking
  the reactor on slow/NFS mounts
- common.py: run D-Bus ShowItems in a background thread so a hung file
  manager doesn't freeze the UI
- gtk3/common.py: pickle state in main thread, write+fsync in background
  thread to avoid blocking GTK on state saves
- preferencesmanager.py: add 10s timeout to urlopen in stats sender
- tests: fix unused imports flagged by ruff

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: flound1129

deluge/common.py

@@ -351,22 +351,29 @@ def show_file(path, timestamp=None):
             timestamp,
         )
 
-        if dbus:
-            bus = dbus.SessionBus()
+        def _show_via_dbus():
             try:
+                bus = dbus.SessionBus()
                 filemanager1 = bus.get_object(DBUS_FM_ID, DBUS_FM_PATH)
-            except dbus.exceptions.DBusException as ex:
-                log.debug('Unable to get dbus file manager: %s', ex)
-                # Fallback to xdg-open
-            else:
                 paths = [urljoin('file:', pathname2url(path))]
                 filemanager1.ShowItems(paths, startup_id, dbus_interface=DBUS_FM_ID)
-                return
+            except Exception as ex:
+                log.debug('Unable to show file via dbus: %s', ex)
+                env = os.environ.copy()
+                env['DESKTOP_STARTUP_ID'] = startup_id.replace('dbus', 'xdg-open')
+                subprocess.Popen(
+                    ['xdg-open', os.path.dirname(path.rstrip('/'))], env=env
+                )
 
-        env = os.environ.copy()
-        env['DESKTOP_STARTUP_ID'] = startup_id.replace('dbus', 'xdg-open')
-        # No option in xdg to highlight a file so just open parent folder.
-        subprocess.Popen(['xdg-open', os.path.dirname(path.rstrip('/'))], env=env)
+        if dbus:
+            import threading
+
+            threading.Thread(target=_show_via_dbus, daemon=True).start()
+        else:
+            env = os.environ.copy()
+            env['DESKTOP_STARTUP_ID'] = startup_id.replace('dbus', 'xdg-open')
+            # No option in xdg to highlight a file so just open parent folder.
+            subprocess.Popen(['xdg-open', os.path.dirname(path.rstrip('/'))], env=env)
 
 
 def open_url_in_browser(url):

deluge/config.py

@@ -225,7 +225,7 @@ def do_change_callbacks(key, value):
 
             self.callLater(0, do_change_callbacks, key, value)
         except Exception:
-            pass
+            log.warning('Failed to schedule config change callback for key: %s', key)
 
         # We set the save_timer for 5 seconds if not already set
         if not self._save_timer or not self._save_timer.active():

deluge/core/core.py

@@ -1276,24 +1276,25 @@ def on_error(failure):
         return d
 
     @export
-    def get_free_space(self, path: str = None) -> int:
+    def get_free_space(self, path: str = None):
         """Returns the number of free bytes at path
 
         Args:
             path: the path to check free space at, if None, use the default download location
 
         Returns:
-            the number of free bytes at path
-
-        Raises:
-            InvalidPathError: if the path is invalid
+            Deferred: the number of free bytes at path, or -1 on error
         """
         if not path:
             path = self.config['download_location']
-        try:
-            return deluge.common.free_space(path)
-        except InvalidPathError:
-            return -1
+
+        def _get_free_space(path):
+            try:
+                return deluge.common.free_space(path)
+            except InvalidPathError:
+                return -1
+
+        return threads.deferToThread(_get_free_space, path)
 
     def _on_external_ip_event(self, external_ip):
         self.external_ip = external_ip

deluge/core/preferencesmanager.py

@@ -427,7 +427,7 @@ def run(self):
                             + '&plugins='
                             + quote_plus(':'.join(self.config['enabled_plugins']))
                         )
-                        urlopen(url)
+                        urlopen(url, timeout=10)
                     except OSError as ex:
                         log.debug('Network error while trying to send info: %s', ex)
                     else:

deluge/tests/test_rpcserver.py

@@ -12,7 +12,7 @@
 from deluge.conftest import BaseTestCase
 from deluge.core import rpcserver
 from deluge.core.authmanager import AuthManager
-from deluge.core.rpcserver import SquallRPCProtocol, RPCServer
+from deluge.core.rpcserver import RPCServer, SquallRPCProtocol
 from deluge.log import setup_logger
 
 setup_logger('none')

deluge/tests/test_torrent.py

@@ -8,6 +8,7 @@
 import time
 from base64 import b64encode
 from unittest import mock
+from unittest.mock import AsyncMock
 
 import pytest
 from twisted.internet import defer, reactor
@@ -24,8 +25,6 @@
 from deluge.core.torrent import Torrent
 from deluge.core.torrentmanager import TorrentManager, TorrentState
 
-from unittest.mock import AsyncMock
-
 
 class TestTorrent(BaseTestCase):
     def setup_config(self):

deluge/ui/gtk3/common.py

@@ -284,33 +284,45 @@ def save_pickled_state_file(filename, state):
         filename (str): Filename to be saved to config
         state (state): The data to be pickled and written to file
     """
+    import threading
+
     from deluge.configmanager import get_config_dir
 
     filepath = os.path.join(get_config_dir(), 'gtk3ui_state', filename)
     filepath_bak = filepath + '.bak'
     filepath_tmp = filepath + '.tmp'
 
+    # Pickle in the main thread (not thread-safe), write in a background thread.
     try:
-        if os.path.isfile(filepath):
-            log.debug('Creating backup of %s at: %s', filename, filepath_bak)
-            shutil.copy2(filepath, filepath_bak)
-    except OSError as ex:
-        log.error('Unable to backup %s to %s: %s', filepath, filepath_bak, ex)
-    else:
+        data = pickle.dumps(state, protocol=2)
+    except pickle.PicklingError as ex:
+        log.error('Unable to pickle %s: %s', filename, ex)
+        return
+
+    def _write():
+        try:
+            if os.path.isfile(filepath):
+                log.debug('Creating backup of %s at: %s', filename, filepath_bak)
+                shutil.copy2(filepath, filepath_bak)
+        except OSError as ex:
+            log.error('Unable to backup %s to %s: %s', filepath, filepath_bak, ex)
+            return
+
         log.info('Saving the %s at: %s', filename, filepath)
         try:
             with open(filepath_tmp, 'wb') as _file:
-                # Pickle the state object
-                pickle.dump(state, _file, protocol=2)
+                _file.write(data)
                 _file.flush()
                 os.fsync(_file.fileno())
             shutil.move(filepath_tmp, filepath)
-        except (OSError, EOFError, pickle.PicklingError) as ex:
+        except (OSError, EOFError) as ex:
             log.error('Unable to save %s: %s', filename, ex)
             if os.path.isfile(filepath_bak):
                 log.info('Restoring backup of %s from: %s', filename, filepath_bak)
                 shutil.move(filepath_bak, filepath)
 
+    threading.Thread(target=_write, daemon=True).start()
+
 
 def load_pickled_state_file(filename):
     """Loads a file from the config directory, attempting backup if original fails to load.