Removing Loader thread, everythings works better... Damn QThread

src/cutecoin/core/app.py

@@ -48,8 +48,7 @@ class Application(QObject):
         self.available_version = __version__
         self._network_manager = QNetworkAccessManager(self)
         config.parse_arguments(argv)
-        self._network_manager.finished.connect(lambda reply: logging.debug("Thread : {0} , Network : {1}".format(self.thread(),
-                                                                                                    reply.url().toString())))
+        self._network_manager.finished.connect(lambda reply: logging.debug("Network : {0}".format(reply.url().toString())))
         self.get_last_version()
         self.preferences = {'account': "",
                             'lang': 'en_GB',

src/cutecoin/core/net/discover/network.py

@@ -7,6 +7,7 @@ from .node import Node
 
 import logging
 import time
+from ucoinpy.documents.peer import Peer
 
 from PyQt5.QtCore import pyqtSignal, pyqtSlot, QObject, QCoreApplication, QTimer
 
@@ -150,7 +151,6 @@ class Network(QObject):
         self._nodes.append(node)
         node.changed.connect(self.handle_change)
         node.neighbour_found.connect(self.handle_new_node)
-        node.destroyed.connect(lambda: logging.debug("Node destroyed"))
         logging.debug("{:} connected".format(node.pubkey[:5]))
 
     def add_root_node(self, node):
@@ -184,13 +184,19 @@ class Network(QObject):
         Start crawling which never stops.
         To stop this crawling, call "stop_crawling" method.
         '''
-        self._must_crawl = True
-        self._is_perpetual = True
-        for node in self.nodes:
-            node.refresh()
+        if not self.continue_crawling():
+            return
+        for (i, node) in enumerate(self.nodes):
+            if not self.continue_crawling():
+                return
 
-    @pyqtSlot()
+            if node == self.nodes[-1]:
+                QTimer.singleShot((i+1)*10000, self.discover_network)
+            QTimer.singleShot(i*10000, node.refresh)
+
+    @pyqtSlot(Peer)
     def handle_new_node(self, peer):
+        logging.debug("New node found : {0}".format(peer.pubkey[:5]))
         pubkeys = [n.pubkey for n in self.nodes]
         if peer.pubkey not in pubkeys:
             node = Node.from_peer(self._currency, peer)
@@ -210,4 +216,5 @@ class Network(QObject):
         logging.debug("{0} -> {1}".format(self.latest_block, self.latest_block))
         if self._block_found < self.latest_block:
             logging.debug("New block found : {0}".format(self.latest_block))
+            self._block_found = self.latest_block
             self.new_block_mined.emit(self.latest_block)

src/cutecoin/core/net/discover/node.py

@@ -43,7 +43,7 @@ class Node(QObject):
     neighbour_found = pyqtSignal(Peer)
 
     def __init__(self, network_manager, currency, endpoints, uid, pubkey, block,
-                 state, last_change):
+                 state, last_change, last_merkle):
         '''
         Constructor
         '''
@@ -57,6 +57,7 @@ class Node(QObject):
         self._neighbours = []
         self._currency = currency
         self._last_change = last_change
+        self._last_merkle = last_merkle
 
     @classmethod
     def from_address(cls, network_manager, currency, address, port):
@@ -78,8 +79,8 @@ class Node(QObject):
                 raise InvalidNodeCurrency(peer.currency, currency)
 
         node = cls(network_manager, peer.currency, peer.endpoints,
-                   "", peer.pubkey, 0,
-                   Node.ONLINE, time.time())
+                   "", peer.pubkey, 0, Node.ONLINE, time.time(),
+                   {'root': "", 'leaves': []})
         logging.debug("Node from address : {:}".format(str(node)))
         return node
 
@@ -97,7 +98,8 @@ class Node(QObject):
                 raise InvalidNodeCurrency(peer.currency, currency)
 
         node = cls(network_manager, peer.currency, peer.endpoints, "", "", 0,
-                   Node.ONLINE, time.time())
+                   Node.ONLINE, time.time(),
+                   {'root': "", 'leaves': []})
         logging.debug("Node from peer : {:}".format(str(node)))
         return node
 
@@ -135,7 +137,8 @@ class Node(QObject):
 
         node = cls(network_manager, currency, endpoints,
                    uid, pubkey, block,
-                   state, last_change)
+                   state, last_change,
+                   {'root': "", 'leaves': []})
         logging.debug("Node from json : {:}".format(str(node)))
         return node
 
@@ -249,20 +252,12 @@ class Node(QObject):
         logging.debug("Requesting {0}".format(conn_handler))
         reply = qtbma.blockchain.Current(conn_handler).get()
 
-        reply.finished.connect(lambda: self.handle_block_reply(reply))
+        reply.finished.connect(self.handle_block_reply)
 
     @pyqtSlot()
-    def handle_block_reply(self, reply):
-        logging.debug("Handle block reply")
-        #reply = self.sender()
-        logging.debug("Found thread : {0}".format(self.thread()))
-        logging.debug("Found reply : {0}".format(reply))
-        logging.debug("Found sender : {0}".format(self.sender()))
-        logging.debug("Found url : {0}".format(reply.url().toString()))
-        logging.debug("Found manager : {0}".format(reply.manager()))
+    def handle_block_reply(self):
+        reply = self.sender()
         status_code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
-        logging.debug("Status code : {0}".format(status_code))
-        logging.debug("Error : {0}".format(reply.error()))
 
         if self.check_noerror(reply.error(), status_code):
             if status_code == 200:
@@ -287,11 +282,10 @@ class Node(QObject):
                                          self.endpoint.conn_handler().port)
 
         peering_reply = qtbma.network.Peering(conn_handler).get()
-        peering_reply.finished.connect(lambda: self.handle_peering_reply(peering_reply))
+        peering_reply.finished.connect(self.handle_peering_reply)
 
     @pyqtSlot()
-    def handle_peering_reply(self, reply):
-        logging.debug("Handle peering reply")
+    def handle_peering_reply(self):
         reply = self.sender()
         status_code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
 
@@ -321,13 +315,12 @@ class Node(QObject):
                                          self.endpoint.conn_handler().server,
                                          self.endpoint.conn_handler().port)
         uid_reply = qtbma.wot.Lookup(conn_handler, self.pubkey).get()
-        uid_reply.finished.connect(lambda: self.handle_uid_reply(uid_reply))
+        uid_reply.finished.connect(self.handle_uid_reply)
         uid_reply.error.connect(lambda code: logging.debug("Error : {0}".format(code)))
 
     @pyqtSlot()
-    def handle_uid_reply(self, reply):
-        logging.debug("Handle uid reply")
-        #reply = self.sender()
+    def handle_uid_reply(self):
+        reply = self.sender()
         status_code = reply.attribute( QNetworkRequest.HttpStatusCodeAttribute );
 
         if self.check_noerror(reply.error(), status_code):
@@ -358,34 +351,34 @@ class Node(QObject):
                                          self.endpoint.conn_handler().port)
 
         reply = qtbma.network.peering.Peers(conn_handler).get(leaves='true')
-        reply.finished.connect(lambda: self.handle_peers_reply(reply))
+        reply.finished.connect(self.handle_peers_reply)
         reply.error.connect(lambda code: logging.debug("Error : {0}".format(code)))
 
 
     @pyqtSlot()
-    def handle_peers_reply(self, reply):
-        logging.debug("Handle peers reply")
-        #reply = self.sender()
+    def handle_peers_reply(self):
+        reply = self.sender()
         status_code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
 
         if self.check_noerror(reply.error(), status_code):
             strdata = bytes(reply.readAll()).decode('utf-8')
             peers_data = json.loads(strdata)
-            if True: #peers_data['root'] != self._last_root:
-                leaves = [leaf for leaf in peers_data['leaves']]
-                          #if leaf not in self._last_leaves]
+            if peers_data['root'] != self._last_merkle['root']:
+                leaves = [leaf for leaf in peers_data['leaves']
+                          if leaf not in self._last_merkle['leaves']]
                 for leaf_hash in leaves:
                     conn_handler = ConnectionHandler(self.network_manager,
                                                      self.endpoint.conn_handler().server,
                                                      self.endpoint.conn_handler().port)
                     leaf_reply = qtbma.network.peering.Peers(conn_handler).get(leaf=leaf_hash)
-                    leaf_reply.finished.connect(lambda: self.handle_leaf_reply(leaf_reply))
+                    leaf_reply.finished.connect(self.handle_leaf_reply)
+                self._last_merkle = {'root' : peers_data['root'],
+                                     'leaves': peers_data['leaves']}
         else:
             logging.debug("Error in peers reply")
 
     @pyqtSlot()
-    def handle_leaf_reply(self, reply):
-        logging.debug("Handle leaf reply")
+    def handle_leaf_reply(self):
         reply = self.sender()
         status_code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
 

src/cutecoin/gui/mainwindow.py

@@ -9,7 +9,7 @@ from ..gen_resources.about_uic import Ui_AboutPopup
 from PyQt5.QtWidgets import QMainWindow, QAction, QFileDialog, QProgressBar, \
     QMessageBox, QLabel, QComboBox, QDialog, QApplication
 from PyQt5.QtCore import QSignalMapper, QObject, QThread, \
-    pyqtSlot, pyqtSignal, QDate, QDateTime, QTimer, QUrl, Qt
+    pyqtSlot, pyqtSignal, QDate, QDateTime, QTimer, QUrl, Qt, QCoreApplication
 from PyQt5.QtGui import QIcon, QDesktopServices, QPixmap
 
 from .process_cfg_account import ProcessConfigureAccount
@@ -90,13 +90,9 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         self.statusbar.addPermanentWidget(self.combo_referential)
         self.update_time()
 
-        self.loader_thread = QThread()
         self.loader = Loader(self.app)
-        self.loader.moveToThread(self.loader_thread)
         self.loader.loaded.connect(self.loader_finished)
-        self.loader.loaded.connect(self.loader_thread.quit)
         self.loader.connection_error.connect(self.display_error)
-        self.loader_thread.started.connect(self.loader.load)
 
         self.homescreen = HomeScreenWidget(self.app)
         self.centralWidget().layout().addWidget(self.homescreen)
@@ -159,6 +155,7 @@ class MainWindow(QMainWindow, Ui_MainWindow):
             logging.debug("Busybar : {:} : {:}".format(value, maximum))
             self.busybar.setValue(value)
             self.busybar.setMaximum(maximum)
+            QApplication.processEvents()
 
         if self.app.current_account:
             self.app.save_cache(self.app.current_account)
@@ -173,7 +170,7 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         self.busybar.show()
         self.status_label.setText(self.tr("Loading account {0}").format(account_name))
         self.loader.set_account_name(account_name)
-        self.loader_thread.start(QThread.LowPriority)
+        QTimer.singleShot(1000, self.loader.load)
         self.homescreen.button_new.hide()
         self.homescreen.button_import.hide()
 
@@ -371,8 +368,6 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         if self.app.current_account:
             self.app.save_cache(self.app.current_account)
         self.app.save_persons()
-        self.loader.deleteLater()
-        self.loader_thread.deleteLater()
         super().closeEvent(event)
 
     def showEvent(self, event):