refactor handling of bitcoind output

node_launcher/gui/menu.py

@@ -40,12 +40,6 @@ def __init__(self, node_set: NodeSet, system_tray):
             node_set=self.node_set,
             system_tray=self.system_tray
         )
-        self.node_set.bitcoin.process.readyReadStandardError.connect(
-            self.bitcoind_output_widget.handle_error
-        )
-        self.node_set.bitcoin.process.readyReadStandardOutput.connect(
-            self.bitcoind_output_widget.handle_output
-        )
         self.bitcoind_output_action = self.addAction('See Bitcoin Output')
         self.bitcoind_output_action.triggered.connect(
             self.bitcoind_output_widget.show

node_launcher/gui/system_tray_widgets/bitcoind_output_widget.py

@@ -1,15 +1,13 @@
-import os
 from datetime import datetime, timedelta
 
 import humanize
-from PySide2.QtCore import QByteArray, QProcess, QThreadPool, Qt
-from PySide2.QtWidgets import QDialog, QTextEdit
+from PySide2.QtCore import QProcess, QThreadPool, Qt
 
-from node_launcher.gui.components.grid_layout import QGridLayout
+from node_launcher.gui.system_tray_widgets.output_widget import OutputWidget
 from node_launcher.node_set import NodeSet
 
 
-class BitcoindOutputWidget(QDialog):
+class BitcoindOutputWidget(OutputWidget):
     node_set: NodeSet
     process: QProcess
 
@@ -18,79 +16,66 @@ def __init__(self, node_set: NodeSet, system_tray):
         self.node_set = node_set
         self.system_tray = system_tray
         self.process = node_set.bitcoin.process
-        self.setWindowTitle('Bitcoind Output')
-        self.layout = QGridLayout()
 
-        self.threadpool = QThreadPool()
+        self.process.readyReadStandardError.connect(self.handle_error)
+        self.process.readyReadStandardOutput.connect(self.handle_output)
 
-        self.output = QTextEdit()
-        self.output.acceptRichText = True
+        self.setWindowTitle('Bitcoind Output')
 
-        self.layout.addWidget(self.output)
-        self.setLayout(self.layout)
+        self.threadpool = QThreadPool()
 
         self.old_progress = None
         self.old_timestamp = None
 
         self.timestamp_changes = []
 
-    def handle_error(self):
-        output: QByteArray = self.process.readAllStandardError()
-        message = output.data().decode('utf-8').strip()
-        self.output.append(message)
-
-    def handle_output(self):
-        output: QByteArray = self.process.readAllStandardOutput()
-        message = output.data().decode('utf-8').strip()
-        lines = message.split('\n')
-        for line in lines:
-            if 'Bitcoin Core version' in line:
-                self.system_tray.menu.bitcoind_status_action.setText(
-                    'Bitcoin starting'
-                )
-            elif 'Leaving InitialBlockDownload' in line:
-                self.system_tray.menu.bitcoind_status_action.setText(
-                    'Bitcoin synced'
-                )
-            elif 'Shutdown: done' in line:
-                self.system_tray.menu.bitcoind_status_action.setText(
-                    'Error, please check Bitcoin Output'
-                )
-            elif 'UpdateTip' in line:
-                line_segments = line.split(' ')
-                timestamp = line_segments[0]
-                for line_segment in line_segments:
-                    if 'progress' in line_segment:
-                        new_progress = round(float(line_segment.split('=')[-1]), 4)
-                        new_timestamp = datetime.strptime(
-                            timestamp,
-                            '%Y-%m-%dT%H:%M:%SZ'
-                        )
-                        if new_progress != self.old_progress:
-                            if self.old_progress is not None:
-                                change = new_progress - self.old_progress
-                                timestamp_change = new_timestamp - self.old_timestamp
-                                total_left = 1 - new_progress
-                                time_left = ((total_left / change)*timestamp_change).seconds
-                                self.timestamp_changes.append(time_left)
-                                if len(self.timestamp_changes) > 100:
-                                    self.timestamp_changes.pop(0)
-                                average_time_left = sum(self.timestamp_changes)/len(self.timestamp_changes)
-                                humanized = humanize.naturaltime(-timedelta(seconds=average_time_left))
-                                self.system_tray.menu.bitcoind_status_action.setText(
-                                    f'ETA: {humanized}, {new_progress*100:.2f}% done'
-                                )
-                            else:
-                                if round(new_progress*100) == 100:
-                                    continue
-                                self.system_tray.menu.bitcoind_status_action.setText(
-                                    f'{new_progress*100:.2f}%'
-                                )
+    def process_output_line(self, line: str):
+        if 'Bitcoin Core version' in line:
+            self.system_tray.menu.bitcoind_status_action.setText(
+                'Bitcoin starting'
+            )
+        elif 'Leaving InitialBlockDownload' in line:
+            self.system_tray.menu.bitcoind_status_action.setText(
+                'Bitcoin synced'
+            )
+        elif 'Shutdown: done' in line:
+            self.system_tray.menu.bitcoind_status_action.setText(
+                'Error, please check Bitcoin Output'
+            )
+        elif 'UpdateTip' in line:
+            line_segments = line.split(' ')
+            timestamp = line_segments[0]
+            for line_segment in line_segments:
+                if 'progress' in line_segment:
+                    new_progress = round(float(line_segment.split('=')[-1]), 4)
+                    new_timestamp = datetime.strptime(
+                        timestamp,
+                        '%Y-%m-%dT%H:%M:%SZ'
+                    )
+                    if new_progress != self.old_progress:
+                        if self.old_progress is not None:
+                            change = new_progress - self.old_progress
+                            timestamp_change = new_timestamp - self.old_timestamp
+                            total_left = 1 - new_progress
+                            time_left = ((total_left / change)*timestamp_change).seconds
+                            self.timestamp_changes.append(time_left)
+                            if len(self.timestamp_changes) > 100:
+                                self.timestamp_changes.pop(0)
+                            average_time_left = sum(self.timestamp_changes)/len(self.timestamp_changes)
+                            humanized = humanize.naturaltime(-timedelta(seconds=average_time_left))
+                            self.system_tray.menu.bitcoind_status_action.setText(
+                                f'ETA: {humanized}, {new_progress*100:.2f}% done'
+                            )
+                        else:
+                            if round(new_progress*100) == 100:
+                                continue
+                            self.system_tray.menu.bitcoind_status_action.setText(
+                                f'{new_progress*100:.2f}%'
+                            )
 
-                            self.old_progress = new_progress
-                            self.old_timestamp = new_timestamp
+                        self.old_progress = new_progress
+                        self.old_timestamp = new_timestamp
 
-            self.output.append(line)
 
     def show(self):
         self.showMaximized()

node_launcher/gui/system_tray_widgets/lnd_output_widget.py

@@ -4,11 +4,9 @@
 # noinspection PyPackageRequirements
 from grpc._channel import _Rendezvous
 import humanize
-from PySide2.QtCore import QByteArray, QThreadPool, QProcess, Qt, QTimer
-from PySide2.QtWidgets import QDialog, QTextEdit
+from PySide2.QtCore import QThreadPool, Qt, QTimer
 
 from node_launcher.constants import keyring
-from node_launcher.gui.components.grid_layout import QGridLayout
 from node_launcher.gui.components.thread_worker import Worker
 from node_launcher.gui.system_tray_widgets.output_widget import OutputWidget
 from node_launcher.logging import log
@@ -22,30 +20,61 @@ def __init__(self, node_set: NodeSet, system_tray):
         self.node_set = node_set
         self.system_tray = system_tray
         self.process = node_set.lnd.process
-        self.process.readyReadStandardError.connect(
-            self.handle_error
-        )
-        self.process.readyReadStandardOutput.connect(
-            self.handle_output
-        )
+        self.process.readyReadStandardError.connect(self.handle_error)
+        self.process.readyReadStandardOutput.connect(self.handle_output)
         self.setWindowTitle('LND Output')
-        self.layout = QGridLayout()
 
         self.threadpool = QThreadPool()
 
-        self.output = QTextEdit()
-        self.output.acceptRichText = True
-
-        self.layout.addWidget(self.output)
-        self.setLayout(self.layout)
-
         self.old_height = None
         self.old_timestamp = None
 
-    def handle_error(self):
-        output: QByteArray = self.process.readAllStandardError()
-        message = output.data().decode('utf-8').strip()
-        self.output.append(message)
+    def process_output_line(self, line: str):
+        self.output.append(line)
+        if 'Active chain: Bitcoin' in line:
+            self.system_tray.menu.lnd_status_action.setText(
+                'LND starting'
+            )
+        elif 'Waiting for wallet encryption password' in line:
+            self.system_tray.menu.lnd_status_action.setText(
+                'LND unlocking wallet'
+            )
+            QTimer.singleShot(100, self.auto_unlock_wallet)
+        elif 'Shutdown complete' in line:
+            QTimer.singleShot(3000, self.process.start)
+        elif 'Unable to synchronize wallet to chain' in line:
+            self.process.terminate()
+            QTimer.singleShot(3000, self.process.start)
+        elif 'LightningWallet opened' in line:
+            self.system_tray.set_blue()
+            self.system_tray.menu.lnd_status_action.setText(
+                'LND syncing with network'
+            )
+        elif 'Starting HTLC Switch' in line:
+            self.system_tray.set_green()
+            self.system_tray.menu.lnd_status_action.setText(
+                'LND synced'
+            )
+        elif 'Caught up to height' in line:
+            new_height = int(line.split(' ')[-1])
+            timestamp = line.split('[INF]')[0].strip()
+            new_timestamp = datetime.strptime(
+                timestamp,
+                '%Y-%m-%d %H:%M:%S.%f'
+            )
+            if self.old_height is not None:
+                change = new_height - self.old_height
+                timestamp_change = new_timestamp - self.old_timestamp
+                total_left = 600000 - new_height
+                time_left = (total_left / change)*timestamp_change
+                humanized = humanize.naturaltime(-time_left)
+                self.system_tray.menu.lnd_status_action.setText(
+                    f'ETA: {humanized}, caught up to height {new_height}'
+                )
+
+            self.old_height = new_height
+            self.old_timestamp = new_timestamp
+
 
     @staticmethod
     def unlock_wallet(lnd, progress_callback, password: str):
@@ -165,52 +194,6 @@ def auto_unlock_wallet(self):
         worker.signals.result.connect(self.handle_unlock_wallet)
         self.threadpool.start(worker)
 
-    def process_output_line(self, line: str):
-        self.output.append(line)
-        if 'Active chain: Bitcoin' in line:
-            self.system_tray.menu.lnd_status_action.setText(
-                'LND starting'
-            )
-        elif 'Waiting for wallet encryption password' in line:
-            self.system_tray.menu.lnd_status_action.setText(
-                'LND unlocking wallet'
-            )
-            QTimer.singleShot(100, self.auto_unlock_wallet)
-        elif 'Shutdown complete' in line:
-            QTimer.singleShot(3000, self.process.start)
-        elif 'Unable to synchronize wallet to chain' in line:
-            self.process.terminate()
-            QTimer.singleShot(3000, self.process.start)
-        elif 'LightningWallet opened' in line:
-            self.system_tray.set_blue()
-            self.system_tray.menu.lnd_status_action.setText(
-                'LND syncing with network'
-            )
-        elif 'Starting HTLC Switch' in line:
-            self.system_tray.set_green()
-            self.system_tray.menu.lnd_status_action.setText(
-                'LND synced'
-            )
-        elif 'Caught up to height' in line:
-            new_height = int(line.split(' ')[-1])
-            timestamp = line.split('[INF]')[0].strip()
-            new_timestamp = datetime.strptime(
-                timestamp,
-                '%Y-%m-%d %H:%M:%S.%f'
-            )
-            if self.old_height is not None:
-                change = new_height - self.old_height
-                timestamp_change = new_timestamp - self.old_timestamp
-                total_left = 600000 - new_height
-                time_left = (total_left / change)*timestamp_change
-                humanized = humanize.naturaltime(-time_left)
-                self.system_tray.menu.lnd_status_action.setText(
-                    f'ETA: {humanized}, caught up to height {new_height}'
-                )
-
-            self.old_height = new_height
-            self.old_timestamp = new_timestamp
-
     def show(self):
         self.showMaximized()
         self.raise_()

node_launcher/gui/system_tray_widgets/output_widget.py

@@ -1,5 +1,5 @@
 from PySide2.QtCore import QByteArray, QProcess
-from PySide2.QtWidgets import QDialog
+from PySide2.QtWidgets import QDialog, QGridLayout, QTextEdit
 
 from node_launcher.node_set import NodeSet
 
@@ -10,9 +10,22 @@ class OutputWidget(QDialog):
 
     def __init__(self):
         super().__init__()
+        self.layout = QGridLayout()
+        self.output = QTextEdit()
+        self.output.setReadOnly(True)
+        self.output.acceptRichText = True
+        self.output.document().setMaximumBlockCount(1000)
+        self.layout.addWidget(self.output)
+        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)
+
+    def handle_error(self):
+        output: QByteArray = self.process.readAllStandardError()
+        message = output.data().decode('utf-8').strip()
+        self.output.append(message)