Re-arrange get_keyring() for clarity

Author: m3nu

src/vorta/borg/borg_thread.py

@@ -144,7 +144,7 @@ def prepare(cls, profile):
             return ret
 
         # Try to fall back to DB Keyring, if we use the system keychain.
-        if ret['password'] is None and cls.keyring.is_primary:
+        if ret['password'] is None and cls.keyring.is_system:
             logger.debug('Password not found in primary keyring. Falling back to VortaDBKeyring.')
             ret['password'] = VortaDBKeyring().get_password('vorta-repo', profile.repo.url)
 

src/vorta/keyring/abc.py

@@ -13,42 +13,46 @@ class VortaKeyring:
     @classmethod
     def get_keyring(cls):
         """
-        Attempts to get secure keyring at runtime if current keyring is insecure.
-        Once it finds a secure keyring, it wil always use that keyring
+        Choose available Keyring or save passwords to settings database.
+
+        Will always use Keychain on macOS. Will try KWallet and then Secret
+        Storage on Linux and *BSD. If non are available or usage of system keychain
+        is disabled, fall back to saving passwords to DB.
         """
 
-        # Using system keychain is disabled in settings
         from vorta.models import SettingsModel
-        if not SettingsModel.get(key='use_system_keyring').value:
-            from .db import VortaDBKeyring
-            cls._keyring = VortaDBKeyring()
-        elif cls._keyring is None or not cls._keyring.is_primary:
-            if sys.platform == 'darwin':  # Use Keychain on macOS
-                from .darwin import VortaDarwinKeyring
-                cls._keyring = VortaDarwinKeyring()
-            else:
-                # Try to use KWallet (KDE)
-                from .kwallet import VortaKWallet5Keyring, KWalletNotAvailableException
-                try:
-                    cls._keyring = VortaKWallet5Keyring()
-                except KWalletNotAvailableException:
-                    # Try to use DBus and Gnome-Keyring (available on Linux and *BSD)
-                    # Put this last as gnome keyring is included by default on many distros
-                    import secretstorage
-                    from .secretstorage import VortaSecretStorageKeyring
-
-                    # secretstorage has two different libraries based on version
-                    if parse_version(secretstorage.__version__) >= parse_version("3.0.0"):
-                        from jeepney.wrappers import DBusErrorResponse as DBusException
-                    else:
-                        from dbus.exceptions import DBusException
+        from .db import VortaDBKeyring
 
+        if SettingsModel.get(key='use_system_keyring').value:
+            if cls._keyring is None or not cls._keyring.is_system:
+                # macOS: Only Keychain available
+                if sys.platform == 'darwin':
+                    from .darwin import VortaDarwinKeyring
+                    cls._keyring = VortaDarwinKeyring()
+                else:
+                    # Others: Try KWallet first
+                    from .kwallet import VortaKWallet5Keyring, KWalletNotAvailableException
                     try:
-                        cls._keyring = VortaSecretStorageKeyring()
-                    except (secretstorage.exceptions.SecretStorageException, DBusException):
-                        # Save passwords in DB, if all else fails.
-                        from .db import VortaDBKeyring
-                        cls._keyring = VortaDBKeyring()
+                        cls._keyring = VortaKWallet5Keyring()
+                    except KWalletNotAvailableException:
+                        # Try to use DBus and Gnome Keyring (available on Linux and *BSD)
+                        # Put this last as Gnome Keyring is included by default on many distros
+                        import secretstorage
+                        from .secretstorage import VortaSecretStorageKeyring
+
+                        # Secret Storage has two different libraries based on version
+                        if parse_version(secretstorage.__version__) >= parse_version("3.0.0"):
+                            from jeepney.wrappers import DBusErrorResponse as DBusException
+                        else:
+                            from dbus.exceptions import DBusException
+                        try:
+                            cls._keyring = VortaSecretStorageKeyring()
+                        except (secretstorage.exceptions.SecretStorageException, DBusException):
+                            # Fall back to using DB, if all else fails.
+                            cls._keyring = VortaDBKeyring()
+        else:
+            cls._keyring = VortaDBKeyring()
+
         return cls._keyring
 
     def set_password(self, service, repo_url, password):
@@ -64,7 +68,7 @@ def get_password(self, service, repo_url):
         raise NotImplementedError
 
     @property
-    def is_primary(self):
+    def is_system(self):
         """
         Return True if the current subclass is the system's primary keychain mechanism,
         rather than a fallback (like our own VortaDBKeyring).

src/vorta/keyring/db.py

@@ -27,7 +27,7 @@ def get_password(self, service, repo_url):
             return None
 
     @property
-    def is_primary(self):
+    def is_system(self):
         return False
 
     @property

src/vorta/utils.py

@@ -344,7 +344,7 @@ def display_password_backend(encryption):
     # flake8: noqa E501
     if encryption != 'none':
         keyring = VortaKeyring.get_keyring()
-        return trans_late('utils', "Storing the password in your password manager.") if keyring.is_primary else trans_late(
+        return trans_late('utils', "Storing the password in your password manager.") if keyring.is_system else trans_late(
             'utils', 'Saving the password to disk. To store password more securely install a supported secret store such as KeepassXC')
     else:
         return ""