[Core] Refactor new features support check

In 1989d0d a check for a daemon version was added.
As this depends on knowing the version in which the feature will be
merged, this approach is not suitable for this.
Therefore, a features enum will help us list all features, without
knowing in which version each was added.

Author: DjLegolas

deluge/_features.py

@@ -0,0 +1,19 @@
+from enum import IntFlag
+from functools import reduce
+from operator import or_ as _or_
+
+
+def _with_limits(enumeration):
+    """add NONE and ALL psuedo-members to enumeration"""
+    none_member = enumeration(0)
+    all_member = enumeration(reduce(_or_, enumeration))
+    enumeration.NONE = none_member
+    enumeration.ALL = all_member
+    enumeration._member_map_['NONE'] = none_member
+    enumeration._member_map_['ALL'] = all_member
+    return enumeration
+
+
+@_with_limits
+class DelugeFeatures(IntFlag):
+    BASE = 1  # marks all features up to 2.2.0

deluge/core/core.py

@@ -22,6 +22,7 @@
 import deluge.common
 import deluge.component as component
 from deluge import metafile, path_chooser_common
+from deluge._features import DelugeFeatures
 from deluge._libtorrent import LT_VERSION, lt
 from deluge.configmanager import ConfigManager, get_config_dir
 from deluge.core.alertmanager import AlertManager
@@ -1301,3 +1302,8 @@ def update_account(self, username: str, password: str, authlevel: str) -> bool:
     @export(AUTH_LEVEL_ADMIN)
     def remove_account(self, username: str) -> bool:
         return self.authmanager.remove_account(username)
+
+    @export
+    def get_supported_features(self) -> int:
+        """Returns the supported features."""
+        return DelugeFeatures.ALL.value

deluge/plugins/Blocklist/deluge_blocklist/gtkui.py

@@ -60,7 +60,7 @@ def disable(self):
         self.plugin.deregister_hook('on_apply_prefs', self._on_apply_prefs)
         self.plugin.deregister_hook('on_show_prefs', self._on_show_prefs)
 
-        del self.glade
+        del self.builder
 
     def update(self):
         def _on_get_status(status):

deluge/tests/test_client.py

@@ -3,11 +3,15 @@
 # the additional special exception to link portions of this program with the OpenSSL library.
 # See LICENSE for more details.
 #
+from unittest.mock import patch
+
 import pytest
 import pytest_twisted
 from twisted.internet import defer
+from twisted.internet import error as twisted_error
 
 from deluge import error
+from deluge._features import DelugeFeatures
 from deluge.common import AUTH_LEVEL_NORMAL, get_localhost_auth, get_version
 from deluge.core.authmanager import AUTH_LEVEL_ADMIN
 from deluge.ui.client import Client, DaemonSSLProxy, client
@@ -72,6 +76,21 @@ def __on_disconnect(self):
             self.disconnect_callback()
 
 
+class NoFeatureDaemonSSLProxy(DaemonSSLProxy):
+    def call(self, method, *args, **kwargs):
+        def on_method_list(methods_list):
+            return tuple(
+                method_name
+                for method_name in methods_list
+                if method_name != 'core.get_supported_features'
+            )
+
+        d = super().call(method, *args, **kwargs)
+        if method == 'daemon.get_method_list':
+            d.addCallback(on_method_list)
+        return d
+
+
 @pytest.mark.usefixtures('daemon', 'client')
 class TestClient:
     def test_connect_no_credentials(self):
@@ -134,6 +153,21 @@ def on_failure(failure):
         d.addCallbacks(self.fail, on_failure)
         return d
 
+    def test_connect_invalid_host(self):
+        username, password = get_localhost_auth()
+        d = client.connect(
+            'somehost', self.listen_port, username=username, password=password
+        )
+
+        def on_failure(failure):
+            assert (
+                failure.trap(twisted_error.DNSLookupError)
+                == twisted_error.DNSLookupError
+            )
+
+        d.addCallbacks(self.fail, on_failure)
+        return d
+
     @pytest_twisted.inlineCallbacks
     def test_connect_with_password(self):
         username, password = get_localhost_auth()
@@ -181,12 +215,33 @@ def test_daemon_version(self):
         assert client.daemon_version == get_version()
 
     @pytest_twisted.inlineCallbacks
-    def test_daemon_version_check_min(self):
+    def test_is_feature_supported(self):
         username, password = get_localhost_auth()
         yield client.connect(
             'localhost', self.listen_port, username=username, password=password
         )
 
-        assert client.daemon_version_check_min(get_version())
-        assert not client.daemon_version_check_min(f'{get_version()}1')
-        assert client.daemon_version_check_min('0.1.0')
+        assert client._daemon_features == DelugeFeatures.ALL
+        assert client.is_feature_supported(DelugeFeatures.BASE)
+        assert not client.is_feature_supported(-1)
+
+    @pytest_twisted.inlineCallbacks
+    def test_is_feature_supported_older_daemon(self):
+        with patch('deluge.ui.client.DaemonSSLProxy', NoFeatureDaemonSSLProxy):
+            username, password = get_localhost_auth()
+            yield client.connect(
+                'localhost', self.listen_port, username=username, password=password
+            )
+
+            assert client._daemon_features == DelugeFeatures.NONE
+            assert not client.is_feature_supported(DelugeFeatures.BASE)
+
+    @pytest_twisted.inlineCallbacks
+    def test_daemon_features_resets_on_disconnect(self):
+        username, password = get_localhost_auth()
+        yield client.connect(
+            'localhost', self.listen_port, username=username, password=password
+        )
+        assert client._daemon_features == DelugeFeatures.ALL
+        yield client.disconnect()
+        assert client._daemon_features == DelugeFeatures.NONE

deluge/tests/test_core.py

@@ -20,6 +20,7 @@
 import deluge.common
 import deluge.component as component
 import deluge.core.torrent
+from deluge._features import DelugeFeatures
 from deluge._libtorrent import lt
 from deluge.conftest import BaseTestCase
 from deluge.core.core import Core
@@ -509,3 +510,7 @@ def test_create_torrent(self, path, tmp_path, piece_length):
             assert f.read() == filecontent
 
         lt.torrent_info(filecontent)
+
+    def test_get_supported_features(self):
+        features = self.core.get_supported_features()
+        assert features == DelugeFeatures.ALL

deluge/ui/client.py

@@ -15,7 +15,8 @@
 from twisted.internet.protocol import ClientFactory
 
 from deluge import error
-from deluge.common import VersionSplit, get_localhost_auth, get_version
+from deluge._features import DelugeFeatures
+from deluge.common import get_localhost_auth, get_version
 from deluge.decorators import deprecated
 from deluge.transfer import DelugeTransferProtocol
 
@@ -561,6 +562,7 @@ def __init__(self):
         self._daemon_proxy = None
         self.disconnect_callback = None
         self.__started_standalone = False
+        self._daemon_features = DelugeFeatures.NONE
 
     def connect(
         self,
@@ -596,6 +598,30 @@ def on_connect_fail(reason):
             self.disconnect()
             return reason
 
+        def get_method_list(auth_level):
+            d = self._daemon_proxy.call('daemon.get_method_list')
+            d.addCallback(on_get_method_list, auth_level)
+            return d
+
+        def on_get_method_list(daemon_methods, auth_level):
+            log.debug('Daemon methods: %s', daemon_methods)
+            if 'core.get_supported_features' in daemon_methods:
+                log.info('Getting daemon supported features')
+                d = self._daemon_proxy.call('core.get_supported_features')
+                d.addCallback(on_get_daemon_features, auth_level)
+                return d
+            else:
+                log.info(
+                    'Unable to get daemon supported features, new features will not be available'
+                )
+                self._daemon_features = DelugeFeatures.NONE
+                return auth_level
+
+        def on_get_daemon_features(daemon_features, auth_level):
+            self._daemon_features = DelugeFeatures(daemon_features)
+            log.debug('Daemon features: %s', self._daemon_features)
+            return auth_level
+
         def on_authenticate(result, daemon_info):
             log.debug('Authentication successful: %s', result)
             return result
@@ -612,6 +638,7 @@ def authenticate(daemon_version, username, password):
             d = self._daemon_proxy.authenticate(username, password)
             d.addCallback(on_authenticate, daemon_version)
             d.addErrback(on_authenticate_fail)
+            d.addCallback(get_method_list)
             return d
 
         d.addCallbacks(on_connected)
@@ -624,6 +651,7 @@ def disconnect(self):
         """
         Disconnects from the daemon.
         """
+        self._daemon_features = DelugeFeatures.NONE
         if self.is_standalone():
             self._daemon_proxy.disconnect()
             self.stop_standalone()
@@ -752,16 +780,9 @@ def daemon_version(self) -> str:
         """
         return self._daemon_proxy.daemon_version if self.connected() else ''
 
-    def daemon_version_check_min(self, min_version=get_version()) -> bool:
-        """Check connected daemon against a minimum version.
-
-        Returns:
-            If connected daemon meets minimum version requirement.
-        """
-        if not (self.daemon_version and min_version):
-            return False
-
-        return VersionSplit(self.daemon_version) >= VersionSplit(min_version)
+    def is_feature_supported(self, feature: DelugeFeatures) -> bool:
+        """Check if the connected daemon supports a given feature"""
+        return self._daemon_features & feature == feature
 
     def register_event_handler(self, event, handler):
         """