Refactor password retrieval

Author: PierreRochard

node_launcher/constants.py

@@ -3,10 +3,19 @@
 import platform
 from typing import Dict
 
-NODE_LAUNCHER_RELEASE = '.'.join(map(str, (6, 0, 6)))
+NODE_LAUNCHER_RELEASE = '.'.join(
+    map(
+        str,
+        (
+            6,
+            0,
+            7
+        )
+    )
+)
 
-TARGET_BITCOIN_RELEASE = 'v0.18.1'
-TARGET_LND_RELEASE = 'v0.7.1-beta'
+TARGET_BITCOIN_RELEASE = 'v0.21.1'
+TARGET_LND_RELEASE = 'v0.13.1-beta'
 
 
 class StringConstant(object):
@@ -55,7 +64,6 @@ class OperatingSystem(StringConstant):
 APPDATA = os.path.abspath(os.environ.get('APPDATA', ''))
 PROGRAMS = os.environ.get('Programw6432', '')
 
-
 NODE_LAUNCHER_DATA_PATH: Dict[OperatingSystem, str] = {
     DARWIN: expanduser('~/Library/Application Support/Node Launcher/'),
     LINUX: expanduser('~/.node_launcher'),
@@ -80,22 +88,25 @@ class OperatingSystem(StringConstant):
 }
 
 UPGRADE = 'Please download the latest version of the Node Launcher: ' \
-                    '<a href="https://github.com/PierreRochard/node-launcher/releases/">' \
-                    'https://github.com/PierreRochard/node-launcher/releases' \
-                    '</a>'
+          '<a href="https://github.com/PierreRochard/node-launcher/releases/">' \
+          'https://github.com/PierreRochard/node-launcher/releases' \
+          '</a>'
 
 GIGABYTE = 1000000000
 
 if IS_WINDOWS:
     from keyring.backends.Windows import WinVaultKeyring
+
     keyring = WinVaultKeyring()
 
 if IS_MACOS:
-    from keyring.backends.OS_X import Keyring
+    from keyring.backends.macOS import Keyring
+
     keyring = Keyring()
 
 if IS_LINUX:
     from keyring.backends.SecretService import Keyring
+
     keyring = Keyring()
 
 AUTOPRUNE_GB = 150

node_launcher/gui/components/thread_worker.py

@@ -1,5 +1,6 @@
 import time
 
+import grpc
 from PySide2.QtCore import QRunnable, Slot, QThreadPool, Signal, QObject, QTimer
 
 import traceback, sys
@@ -68,6 +69,8 @@ def run(self):
         # Retrieve args/kwargs here; and fire processing using them
         try:
             result = self.fn(*self.args, **self.kwargs)
+        except grpc.RpcError as e:
+            self.signals.error.emit(e.args[0].details)
         except:
             traceback.print_exc()
             exctype, value = sys.exc_info()[:2]

node_launcher/gui/system_tray_widgets/lnd_output_widget.py

@@ -43,6 +43,10 @@ def process_output_line(self, line: str):
             QTimer.singleShot(100, self.auto_unlock_wallet)
         elif 'Unable to synchronize wallet to chain' in line:
             self.process.terminate()
+        elif 'Started rescan from block' in line:
+            self.system_tray.menu.lnd_status_action.setText(
+                'LND syncing'
+            )
         elif 'Unable to complete chain rescan' in line:
             self.process.terminate()
         elif 'Starting HTLC Switch' in line:
@@ -75,6 +79,11 @@ def process_output_line(self, line: str):
             self.old_height = new_height
             self.old_timestamp = new_timestamp
 
+        elif 'Shutdown complete' in line:
+            self.system_tray.menu.lnd_status_action.setText(
+                'LND has shutdown'
+            )
+
     def restart_process(self):
         QTimer.singleShot(3000, self.process.start)
 
@@ -90,6 +99,10 @@ def unlock_wallet(lnd, progress_callback, password: str):
             details = e.details()
             return details
 
+    @property
+    def keyring_service_name(self):
+        return f'lnd_{self.node_set.bitcoin.network}_wallet_password'
+
     def generate_seed(self, new_seed_password: str):
         try:
             generate_seed_response = self.node_set.lnd_client.generate_seed(
@@ -134,15 +147,14 @@ def handle_unlock_wallet(self, details: str):
         # User needs to create a new wallet
         elif 'wallet not found' in details:
             new_wallet_password = get_random_password()
-            keyring_service_name = keyring_user_name = f'lnd_wallet_password'
             log.info(
                 'create_wallet',
-                keyring_service_name=keyring_service_name,
-                keyring_user_name=keyring_user_name
+                keyring_service_name=self.keyring_service_name,
+                keyring_user_name=self.keyring_service_name
             )
             keyring.set_password(
-                service=keyring_service_name,
-                username=keyring_user_name,
+                service=self.keyring_service_name,
+                username=self.keyring_service_name,
                 password=new_wallet_password
             )
             seed = self.generate_seed(new_wallet_password)
@@ -160,32 +172,49 @@ def handle_unlock_wallet(self, details: str):
                 username=self.node_set.bitcoin.file['rpcuser'],
                 password=new_wallet_password
             )
+        elif 'invalid passphrase for master public key' in details:
+            self.system_tray.menu.lnd_status_action.setText(
+                'Invalid LND Password'
+            )
         else:
             log.warning(
                 'unlock_wallet failed',
                 details=details,
                 exc_info=True
             )
 
+    def get_password(self):
+        passwords = []
+        for service_name in [self.keyring_service_name, 'lnd_wallet_password']:
+            for user_name in [self.keyring_service_name, self.node_set.bitcoin.file['rpcuser'], 'lnd_wallet_password']:
+                log.info(
+                    'auto_unlock_wallet_get_password',
+                    keyring_service_name=service_name,
+                    keyring_user_name=user_name
+                )
+                password = keyring.get_password(
+                    service=service_name,
+                    username=user_name,
+                )
+                if password is not None:
+                    log.info(
+                        'Successfully got password from',
+                        keyring_service_name=service_name,
+                        keyring_user_name=user_name
+                    )
+                    passwords += [password]
+        return passwords
+
     def auto_unlock_wallet(self):
-        keyring_service_name = f'lnd_{self.node_set.bitcoin.network}_wallet_password'
-        keyring_user_name = self.node_set.bitcoin.file['rpcuser']
-        log.info(
-            'auto_unlock_wallet_get_password',
-            keyring_service_name=keyring_service_name,
-            keyring_user_name=keyring_user_name
-        )
-        password = keyring.get_password(
-            service=keyring_service_name,
-            username=keyring_user_name,
-        )
-        worker = Worker(
-            fn=self.unlock_wallet,
-            lnd=self.node_set.lnd,
-            password=password
-        )
-        worker.signals.result.connect(self.handle_unlock_wallet)
-        self.threadpool.start(worker)
+        for password in self.get_password():
+            worker = Worker(
+                fn=self.unlock_wallet,
+                lnd=self.node_set.lnd,
+                password=password
+            )
+            worker.signals.result.connect(self.handle_unlock_wallet)
+            worker.signals.error.connect(self.handle_unlock_wallet)
+            self.threadpool.start(worker)
 
     def show(self):
         self.showMaximized()

node_launcher/gui/system_tray_widgets/output_widget.py

@@ -19,11 +19,14 @@ def __init__(self):
         self.setLayout(self.layout)
 
     def handle_output(self):
-        while self.process.canReadLine():
-            line_bytes: QByteArray = self.process.readLine()
-            line_str = line_bytes.data().decode('utf-8').strip()
-            self.output.append(line_str)
-            self.process_output_line(line_str)
+        try:
+            while self.process.canReadLine():
+                line_bytes: QByteArray = self.process.readLine()
+                line_str = line_bytes.data().decode('utf-8').strip()
+                self.output.append(line_str)
+                self.process_output_line(line_str)
+        except RuntimeError:
+            return None
 
     def handle_error(self):
         output: QByteArray = self.process.readAllStandardError()